Razvan's Tech

scripster-dist.0.8.s.jar (2.7 MB)

razvanc99@gmail.com

0.8 snapshot with scala 2.9.1

Labels: 
 Featured
 Type-Archive
 OpSys-All

Download

razmutant-0.16.zip (36.8 MB)

razvanc99@gmail.com

v.16 - keyboard and mousepad

Labels: 
 Featured
 Type-Archive
 OpSys-All

Download

razmutant-015a.zip (18.3 MB)

razvanc99@gmail.com

send binary objects through POST

Labels: 
 Type-Archive
 OpSys-All

Download

razmutant-015.zip (18.6 MB)

razvanc99@gmail.com

razmutant 0.1.5

Download

razmutant.zip (15.6 MB)

razvanc99@gmail.com

Razies mutant - older preview 

Download

Why scala - executive overview

razvanc@slideshare.net(razvanc) — Wed, 28 Apr 2010 18:13:38 +0000

A executive overview of why development shops should look into scala.

Scala - brief intro

razvanc@slideshare.net(razvanc) — Fri, 13 Feb 2009 21:48:15 +0000

simple intro to scala for java folks

OMG, scala is a complex language!

noreply@blogger.com (Razvan) — Thu, 13 Oct 2011 21:16:00 +0000

NOTE that I cross-posted this to http://blog.coolscala.com/2011/10/omg-scala-is-complex-language.html

I keep seeing this and, maybe it’s true. Let’s chase this complexity for a bit and go through some of the biggest scala differentiators (from Java or C++, as major OO languages).

Smart compiler infers types

The compiler can infer the types for the most part, so people have to type a lot less repetitive information, which they used to type in both Java and C++. For instance, since “john” is obviously a String, the type of the variable is inferred by the compiler to be String so I don’t have to type it again:

val someone = “John”

I have seen this feature both praised and held against the language as “added complexity”, so I don’t know what to say. I just love typing less and feeling less stupid, every time I declare a value or variable.

Simplified class definitions

Since OO is all about defining classes, scala made do with a bunch of stuff in one go, so that my domain models are dead-simple:

class Person (val firstName:String, val lastName:String)

This, in Java and C++ takes about one page of code: with constructors, getters, setters etc. Scala observed that people don’t need to type one page to inform a stupid compiler that they want a person with a first and last names, so it’s all condensed in this one line, much like a table would look in SQL.

Is this added complexity? Well, I do need to worry about overriding the generated getters/setters ONLY if I need to, so I don’t really know if it’s more complex.

Me? I love this particular feature so much, that honestly, I don’t care what you think J

Unifying methods and operators

All programming languages I know discriminate between methods with names like “append” and operators like “+=”. Some do not even allow re-definition of some hardcoded operators (Java) while some allow infix notation only for operators (C++).

Scala simply makes do with ALL these restrictions and states that the name of a method can be pretty much anything and all can use the infix notation, so I can have:

ListBuffer(1,2,3) append 4

As well as

ListBuffer(1,2,3) += 4

The only difference would be the precedence rules, which are customary in all languages.

Some people obviously would see this as “more complex” than both Java and C++ since they can now do whatever they can… but I see it as “simpler” than both. Operators have been held against C++ before so it really is not surprising that they are held against scala as well.

This is, after all, what makes scala such as perfect DSL framework, allowing natural language such as:

“Mary” with “a purse” and “red shoes” should look “nice”

Types – variance

In both Java and C++, the generics have certain hard-coded and limited behavior (i.e. non-variance) and allow only a few constructs (like List<T extends Person>).

In scala, there is a default behavior, where List[Person] is non-variant, but everything is customizable. If you want co-variance, just tell the compiler List[+Person] or List[-Person] for contra-variance. Just like Java, I can use List[T <: Person] but I can use the reverse just as well: List [T >: Person].

Since scala supports implicits (with finer control than C++), another construct is available: List[T <% Person].

Is this more complicated? Well, just like the operators – it lifts certain limitations of other languages, so it’s both more complicated, since there’s more stuff to learn and simpler, since there’s less rules to live by.

I personally enjoy the extra control… do I actually use it? Not on a daily basis, the defaults are good enough.

Constructors only?

Most languages only allow data types (objects) to be constructed. This is normal in Java and C++.

Well, there’s the flipside, where I can de-construct an object and I don’t mean de-allocating its memory. Consider this:

someone match {

case Person(first,last) => println (“ name is “ + first + ” “ + last)

}

You can see what I mean by de-constructing: took an already created object, someone, and de-constructed into its components. I know this looks foreign to most OO personnel, but trust you me, it is insanely cool and useful. Think what you would have to type in either Java or C++ to achieve the same thing, with if (instanceof) and then type cast and assign two variables and whatnot.

Is this more complex? Well, this is totally new functionality so I guess it is. But I love having it! Trust me, you will, too!

By the way, the match/case construct is way more powerful than your regular switch/case which can only handle constants… we can de-construct types, match constants, match types… and more! Check this out:

someone match {

case Person(first,last) => println (“ name is “ + first + ” “ + last)

case “John” |”Mary” => println (“hello, “ + someone)

case s:String => println (“name is “ + s)

case _ => println (“don’t know what this is…”)

}

Is this more complex? I don’t know… in Java or C++ this is between one and two pages of code. This looks simpler and more intuitive to me… granted, I got used to it but so can you!

Conclusion

There’s more areas of the language, but these are some of the major differences I have time for right now. If you have others, post up and I’ll get into those as well.

I did not get into the functional areas of the language, since that would require comparing with other functional languages and I’m not an FP guy. C++ comes close by allowing passing pointers to methods to other functions while Java 8 I think has some proposed lambda syntax.

Is it more complex? Well, there’s two ways to look at it:

Yes,

There are more symbols and features that one can use
There’s more computer science I need to learn (contra-variance, pattern matching, lambdas, closures etc)

No,

The real-world problems to solve are the same and
To do the same in either Java or C++ is either impossible or takes many times more code… and uglier code at that

What do I think? I don’t really care. To me it was cool to learn these concepts that I had forgotten since university and my new vocabulary allows me to solve the usual problems in just a few lines of code and head for an early lunch, while my mates are still writing some getter or setter…

What do you think?

P.S. This is a great detaiked discussion of complex vs complicated: http://lamp.epfl.ch/~odersky/blogs/isscalacomplex.html

Quick scala – step 1: setup

noreply@blogger.com (Razvan) — Thu, 13 Oct 2011 01:13:00 +0000

This post has a new home. If you want to setup a scala development environment, read: http://blog.coolscala.com/2011/10/quick-scala-step-1-setup.html

Scala DSL technique - if-else constructs

noreply@blogger.com (Razvan) — Wed, 17 Aug 2011 16:29:00 +0000

Believe it or not, I've had a hard time coming up with this construct, so I figured it's worth publishing it, maybe save others the hassle.

You want to come up with a recursive if/else construct, like below (I used a dollar sign to denote the DSL if - I've used wif/welse in the past - use whatever you want):

  var branch = 1

  val expr =

    $if(branch == 1) {

      v("a") := 11

      v("b") := 12

    } $else $if(branch == 2) {

      v("a") := 21

      v("b") := 22

    } $else $if(branch == 3) {

      v("a") := 31

      v("b") := 32

    } $else {

      v("a") := 41

      v("b") := 42

    }

Note the recursive if-else-if-else-if-else. The idea is that the if/else token will modify its own else branch depending on the following else - either the final else {} or an else followed by an if:

  case class TIf(cond: () => Boolean, body: () => Unit, var elsebranch: Option[TElse] = None) extends Token("IF ") {

    val scope = TScope(body)

    def $else[T](body: => T) = { this.lastif.elsebranch = Some(TElse(() => body)); this }

    def $else(i: TIf) = {

      this.lastif.elsebranch = Some(TElseIf(i))

      this

    }

    def lastif = elsebranch.map(_.lastif).getOrElse(this)

    ...

Also note that the way scala works is that the if-else tree is built from the top, so each else() is actually invoked on the root IF, therefore it needs to recursively find the last unbound IF and bind itself there as the elsebranch.

Having said that, find the full code and use it as a template, here.

Enjoy!

P.S. One issue with the simplified version built here is that it doesn't stop you from simple syntax errors like having an if-else-else... how would you fix it so the compiler stops you rather than the runtime exception?

A scala DSL technique - collecting

noreply@blogger.com (Razvan) — Tue, 16 Aug 2011 16:43:00 +0000

When coming up with a scala internal DSL, it is often that one will come up with constructs that produce things that need collected, in a list, tree or similar.

For instance, instructions for a robot:

$if (condition) {

  move(1) :: move(2) :: move(3) :: Nil

  move(1) + move(2) + move(3)

  }

Due to syntax restrictions, it is often that people use operators to chain these, like the overloaded + above.

There is a technique you can use to make this look more familiar:

$if (condition) {

  move(1)

  move(2)

  move(3)

  }

While not the nicest, the idea is to use a static collector and collect the actions in there. You'll need levels, so that collecting nested blocks don't interfere, so there is a stack of collectors. Also, these collectors need to be thread-local so that different collecting threads don't interfere.

A reusable collector is in DslCollector.scala and a sample in DslCollectorTest.scala

For this pattern, you have a Collector, a Collectable and the actual constructs:

  case class move(i: Int) extends DslCollectable



  def test1 = expect(move(1) :: move(2) :: Nil) {

    val collected = new collection.mutable.ListBuffer[Any]()



    DslCollector.collect { collected += _ }(1) { // start a collector level

      move(1) //collects itself

      move(2) //collects itself

    } // collector ends



    collected

  }

You can then embedd this in a higher-level construct of your DSL, like the $if used in the example.

Enjoy!

My worst internet shopping experience - gogglesgiant.com

noreply@blogger.com (Razvan) — Tue, 05 Apr 2011 18:17:00 +0000

My worst internet shopping experience, by far, has been with GogglesGiant.com , trying to get replacement goggles for my son's ski goggles, in the middle of the season.Order two pairs, in early February, from their online store at gogglesgiant.com, promises of fast shipping etc.

After two weeks I ask them that I haven't' seen a shipping notice and what's the delay and they reply that there's a high order volume and will ship when they can! Seriously, I will forward anyone their email!

I know I should've asked for the order to be cancelled right there, but I can't take a hint, eh?

After another week I receive a shipment notice with no tracking number. After another 3 weeks I receive the package, for a grand total of 6 weeks.

By now is late March and the season is basically over!

Done? Nope.They screw up and send me the wrong size for one of the lens. I write them back with a photo of the SKU and get ignored! After 1 week, I write again and receive this reply: mail us back the wrong lens and we will refund the cost of the lens. They refuse to send me the right lens, will just refund the cost, without shipping charges.

Reason: "we can't modify the original order". Seriously? I know it sounds too hard to believe, but these guys are for real! Again, I will forward anyone their original emails!

I get stuff shipped for free from Hong Kong in 3 weeks and these guys take 5-6 weeks! They refuse to make good on the order! It's insane, really! I would seriously suggest you look elsewhere for goggles. Ebay hasn't failed me yet. Actually this was the first time I strayed from Amazon and Ebay and I get screwed.

Also, they are a Yahoo Store and theirs is the worse complaining and merchant rating system ever. I hope they go banckrupt. I will and you should avoid any so called Yahoo Store.

I won't send them the wrong size only to get screwed again. I'll loose 40$ but I won't throw more good moneys after the bad.

Again - Goggles Giant cost me 40$, send me the wrong size, didn't send the order until after the season was over and have the worse customer service online... who lies through their nose!

Unfortunately I don't have a lot of recourse here. I can't even open a ticket with my credit card company because it has been like 9 weeks already now... smart buggers! Yahoo stores accept complaints only 6 weeks and after 30 minutes of browsing their website I can't even figure out how to rate this store or open a complaint!

Argh!

Scala DSL - realistic looking options

noreply@blogger.com (Razvan) — Fri, 21 Jan 2011 22:39:00 +0000

Trying to simulate the way options are passed to unix commands via '-'.

The idea is to define a set of applicable flags and an - operator. The end result is being able to write this beauty:

rm -r -f apply "gigi.file"

Without further ado, here's the sample code:

We're limiting the flags and making this type-safe with the Flag case class. If you had more types of commands, you could limit the actual flags for each of them with custom Flag classes.

The main idea is counting on scala's infix notation. The different flags accumulate in sequence and in the end, the resulting command (now with flags) is applied.

The magic of the infix notation is revealed by this equivalent form:

rm.-(r).-(f).apply("gigi.file")

Further things to consider:

combining options
simplifying away the "apply" from the syntax

This sample is available here and I wrote it while playing with a unix-looking scala shell for file management: https://github.com/razie/scalafs.

Have fun!

Embracing change

noreply@blogger.com (Razvan) — Thu, 02 Dec 2010 16:29:00 +0000

A little story of changes and why having options is awesome.

My favorite browser was Chrome, obviously. Until I got a tablet PC and Chrome sucked at multitouch and gestures. Then my favourite browser became IE… of all things. Then I wanted to disable flash to get more juice out of the battery and less crap on the screen… now my default browser is Firefox.

My favorite Twitter client was Tweetdeck until I got really bored with its inability to browse wide when I turned the iPhone around. Now my favourite tweet client is Twitter’s.

A few things to note from this:

The “bar” keeps rising as useful features become standard.
Change is accelerating and the world is a better place because of this.
Competition and voting with feet is insanely healthy (or healthy for the insane?).
I think that most people put up with missing features only for a while and what really kills software is slowness to evolve as well as lack of frequent releases.
One must always have some cheap features on a short term roadmap, to ensure that clients will get something continuously

It also begs a few questions:

Do you think that people become accustomed to seeing through the software they use and focus on the actual problem, switching said software often?
How does this translate into a change-hating enterprise environment?
Why do we still have politicians?

P.S. I wrote this using vi inside a Word document, on my tablet, while commuting to work; published it by tethering my internet connection through the iPhone while listening to an internet radio station stream…how cool is that? Can that be considered “giving back to the internet”? Are we Borg?

P.S. 2 - right after, iPhone crashed 3 times trying to sever the tether...not sure what that means...

A scala Workflow: Engine and DSL

noreply@blogger.com (Razie) — Wed, 15 Sep 2010 15:04:00 +0000

I've been meaning to write a workflow engine/language for sometime and recently, some scala DSL discussions gave me the motive. I know there's tons of workflow products but none complete and to my liking.

I started in May, worked on it a few hours here and there, for a few weeks and then didn't find the time to complete, so this is still work-in-progress, a snail-pace kind of progress. Since the basic ideas are in place, I figured it's worth advertising, maybe attract some converts and start a religion!

The project is over at http://github.com/razie/gremlins

Manifesto

This is not really meant to be a full-blown BPEL or BPMN environment, but a tiny, extensible but sweet and easily embedable workflow framework, that one can use to automate things inside the house, study the behavior of certain grains of sand or write more readable and interactive complex algorithms.

There's more details in the vision page http://github.com/razie/gremlins/blob/master/Gremlins.markdown), but these are the basic principles behind this project:

A workflow is just a graph of activities through which an engine carves one or more concurrent paths

The workflow has many views: text DSL, scala DSL, graphical etc

There's only a small set of base/core activities.

Complex activities are built as patterns from lower-level activities

There's a gremlin distribution API, uniformly implemented by all engines and components in a cloud

Branches (sections of the graph) of a bigger workflow could run on multiple devices/agents

Distributed branches, wherever they run, can be related back and managed as a unit

Since these are all plain graphs, certain graph transformations should be able to turn a state machine into a workflow or a PI into a BPEL or whatever you want into something you'd like...

So far, 1-4 are prototyped and 5-8 are "in progress": a basic concurrent engine and DSL are in place... I dind't get to the distributed part yet.

Examples

The magic of a scala DSL makes this simple CSP style workflow possible:

Doesn't look like scala code? Well... it is and it's proof of why scala is scalable! Of course, this comes with one of those "don't do this at home" annotations.

More complex examples include a scala version:

or a text version:

If you'd like to stay up-to-date, follow me on http://twitter.com/razie - among boring tweets of mine or interesting re-tweets of others, you may find some updates on my projects.

Enjoy!

The Book Of JOSH

noreply@blogger.com (Razie) — Wed, 18 Aug 2010 16:14:00 +0000

[Razie's note] I recently realized that I'm also shifting my mental models trending back to simplicity, so I wanted to re-read this blog...but could only find a copy of it - the original had disappeared. I enjoyed it a lot and figured the more copies the better, so I shamelessly copied the copy below. Enjoy!

For reasons unknown, this article has been removed from the author’s blog, but Google Reader remembered it for me! I have not been able to find the author’s contact information.

All credits to The Grey Lens Man!

Mar 23, 2009 1:47 PM

The Book Of JOSH

from The Grey Lens Man’s View by The Grey Lens Man

Scala In The Enterprise

Recently, we’ve decided to use Scala as part of an enterprise software solution stack. And I’d like to mention a few things on how the hell that was allowed to happen.

But first lets take a stroll and talk about a thing called enterprise IT.

The Problem

You see, I have a small problem – 3 million lines of RPG and COBOL, 5,500 logical and physical files on a few AS400s that are not exactly cheap. Even better through the years, the system has been cloned and forked so several incompatible versions of exist through out the world.

A few years ago I spent 3 months focused on the “original” implementation in a architectural reverse engineering exercise. The result, I know roughly the raison d’etre for 10% or ~ 300K SLOC of code and a few hundred files. 90% of that self-contained universe of code and tables is my personal dark matter question, I know its out there, just no clue as to its nature.

I won’t go into excruciating detail, but let me leave it like this; within that 2.5 T of data there resides a special flag in the customer file, which determines the fundamental nature of how a customer interacts with the system, and it can be found in Filler3, third byte from the left. In one file, the Account ID column sometimes actually does contain the Account number but not alway, sometimes its something else and its torched us. And you’ll never guess what that ZipLoc3 column_really_ contains (hint: nothing like a zipcode).

Yet this system is responsible for several billion in revenue. If the mainframe goes off line a few pagers chirp, but if that system goes off line, it’s klaxons and battle stations.

Universal agreement, its got to go. It has been end-of-life scheduled more often then a serial killer on death row. IT leadership comes and goes, yet, a full decade later it sits there in the data center laughing at me like an evil essence hosting Steven King basement furnace.

Within the last year of so, it’s reached such a state of chaotic entropy, its decay is not only apparent to IT, but now the business, and worse the customer as well.

What Can Be Done?

No one wants to keep it on life support, so doubling down the head count to reverse entropy, or putting some sort of SOA lipstick on this pig is something we’d like to avoid. The problems are fundamental and systemic.

Being customer facing, it’s where all of the businesses most “brilliant” ideas tend to accumulate through the years. Lets just say they’ve been very creative. Nuff said.

We threw a check at it and a consulting team tried for 18 months to move onto an ERP solution and barely made a dent, though I do believe the team purchased their own private Caribbean Island from the billing fees. It just won’t map to a COTS or ERP package without a struggle and anything less the monetary cost of a government TARP program.

On and off over the years, my boss, out of left field, using the pluralis maiestatis would say “we should rewrite it all from scratch.” Having been broken like John McCain on a few Death Marches I’d look at him repeating “the horror… the horror.”

Then during one of my annual hypomanic phases I’d wake up and just know that if put back together ol’ jelled team from that project back in ‘01, well we could rewrite that sucker in no time. That COCOMO II model, most assuredly did not apply to us. My boss, with a look of concern, would nod sagely and suggest I think about it a bit more. I’d recover my senses in a day or two.

And so it sits in the data center, spewing heat and laughing. And it is evil.

All This Sturm und Drang

As a company we know how to do it by the book as we are several years into an ERP implementation. We have standards documents on how we develop standards, requirements/design/functional templates, change control, copious meetings, PMs, PMO office, analysts, and even a few software developers to actually implement things.

We make RUP look like monkeys with a football, Dilbert but a pale shadow irony of our realism, and Forrestor articles look like descriptions of primitive tribal organization. We have PROCESS.

In addition, we have been a full blown java company for in-house application for years. We got it in spades, Struts, Spring, Hibernate, J2EE, ADF, TOPLINK, Ant, Maven, Eclipse, Rational, …

We drink Kool-Aid by the 55 gallon drum round here.

Java

A number of years ago with the support of a key IT executive, I led a jelled, vertical team which brought Java into the company hard and fast. It was seismic.

There was no end of debate, questions, consternation and gnashing of teeth throughout IT and beyond, which we totally ignored. We didn’t know we were supposed to form a technology introduction committee to shepherd this through the IT Leadership Committee approval process. We damn sure didn’t seek forgiveness after the fact, much less permission before the act.

A wild ride, in a more wild time, this was pre-PROCESS. Small team, modest budget, mega-hours, fun times and a result that the business loved. It gave us the #1 ranking in our industry and we held it for a number of years.

I’m reasonably proficient in and knowledgeable of the Java Universe.

Lets, just say it, Java, by design, is a pretty simplistic language, I would argue even a crippled language for uses other then its original design point, which was certainly not server side enterprise IT. As a result, the cottage industries around Java are practically their own Industrial Sectors.

Java is the Brier Rabbit of IT. Once touched you can’t let go. Its simplistic enough to be inadequate in almost every situation. The commercial world just loves this aspect of Java as they exploit revenue streams from filling these gaps via endless Frameworks, Patterns, APIs, Annotations, IDEs and Toolsets.

The dirty secret of course is 25 – 50% of all of it is pure overhead, without direct value, but necessary to overcome the inherent limitations of Java.

On the other hand, the upside of Java for enterprise IT is pretty obvious. Any problem you might have can be solved with money and armies of plug and play bodies and you get mountains of buzz material for those presentations.

But honestly, is this anyway to deliver the IT solutions your company needs?

Full Circle

Where were we …. Yes, you see, I have a small problem.

So whats the issue, you say? I write a whole blog about nothing, you say? We all know the right answer, you’re pointing out? Yea, I know, its intuitively obvious to the casual observer.

We’ll rewrite it from scratch.

Course we’ll need a cluster of WebSphere Application Servers, and an Oracle RAC cluster for all that data. Don’t forget the middleware needed to transition over from the legacy systems, so toss in an ESB cluster, and what heck a couple of BPEL servers too.

Need a SOA Center of Excellence of course too. Can’t integrate without some common XML Business Object Schemas. Also need to roll the Rational RUP suite and some beefy IDE environments and for that shiny look, sprinkle the works with lots of WS-* sparkly dust. Bake 3-5 years or until done, whenever.

My presentation slides for all this will be killer. I can sell this stuff. I’m good at it. I’ll look like a bloody genius. I’ll have Vendors fawning all over me. And the best part is the bubble on this mess won’t pop for YEARS, when I’ll have plenty of plausible deniability. “Hey the plan was perfect, the business, IT managers and their people were incapable of executing it.”

I feel like the enterprise IT equivalent of an AIG trader pocketing ill gotten gains from writing Credit Default Swaps that we can’t pay off.

Losing My Religion

I’ve lost my faith in it all. I need a new religion.

I don’t want monolithic 10 ton solutions I need to wrestle into place with a small armies. I don’t want clusters of application servers fronting a behemoth RAC data cluster. I don’t want web management consoles which rival the Space Shuttle’s dash board.

I want a simple yet effective structural system where I can select and compose reusable modular solutions into simple, targeted solutions. The solution size should be isomorphic to the problem size. It leverages what it needs to solve the problem and no more.

I don’t want 100K source lines of code, with 33K lines of fluff and stuff. Where one of every in three lines of code has nothing to do with the business logic. Where you can’t even find the business logic in the mounds of patterns, abstractions, frameworks, annotation, cut points and verbosity.

I want the problem domain reflected in the code and the code to capture the essence of the problem domain.

I don’t want massive XML documents constrained by committee designed XSD Schema BODs shuttling around clusters of ESB and BPEL middleware.

I want dirt simple intra system communication in the data center.

The Book Of JOSH

Through a marvelous, even devious, set of circumstances, I’m presented with the opportunity to address my little problem without proscribed constraints, a true green field opportunity.

Json OSGi Scala HTTP

Json delivers on what XML promised. Simple to understand, effective data markup accessible and usable by human and computer alike. Serialization/Deserialization is on par with or faster then XML, Thrift and Protocol Buffers. Sure I’m losing XSD Schema type checking, SOAP and WS-* standardization. I’m taking that trade.

OSGi a standardized dynamic, modular framework for versioned components and services. Pick a logger component, a HTTP server component, a ??? component, add your own internal components and you have a dedicated application solution. Micro deployment with true replacement. What am I giving up? The monolithic J2EE application servlet loaded with 25 frameworks, SCA and XML configuration hell. Taking the trade.

HTTP is simple, effective, fast enough, and widely supported. I’m tired of needlessly complex and endless proprietary protocols to move simple data from A to B with all the accompanying firewall port insanity. Yes, HTTP is not perfect. But I’m taking this trade where I can as well.

All interfaces will be simple REST inspired APIs based on HTTP+JSON. This is an immediate consequence of the JOSH stack.

Scala is by far the toughest, yet the easiest selection in the JOSH stack. I wrestled far more with the JSON or XML or Thrift or Protocol Buffers decision.

Without hesitation I know Scala is the right choice from a pure solutioning aspect. But lets face it, what a tough, tough sell from the propeller headed guys to the pointy headed guys.

First, I’m a bit of a computer language aficionado. I’ve written multiple, actual programs in SML, Scheme, Haskell which I’ve used within the enterprise. Why? Because when faced with certain “one time” problems I can knock out a simple utility far faster XXX then in Java. But in almost all cases these were throw away utilities for one time situations.

I’ve toyed with Dylan, Ruby, Python, Groovy, Lisp, Ocaml, Modula 2, Oberon, …

To date I’ve only advocated and pushed Python for utility scripting at both the Application and System Administration levels. Never, at any time did it ever even cross my mind to advocate anything other then Java and a bit of Python for enterprise application development until now.

Java has been stretched way beyond its modest design point. Its literally falling apart from bloat.

Joshua Boch has numerous presentations of the current state of affairs with Java and the proposed functional extensions and closures are headed. He quotes the following from the Java community.

“I am completely and totally humbled. Laid low. I realize now that I am simply not smart at all. I made the mistake of thinking that I could understand generics. I simply cannot. I just can’t. This is really depressing. It is the first time that I’ve ever not been able to understand something related to computers, in any domain, anywhere, period.”

“I’m the lead architect here, have a PhD in physics, and have been working daily in Java for 10 years and know it pretty well. The other guy is a very senior enterprise developer (wrote an email system that sends 600 million emails/year with almost no maintenance). If we can’t get [generics], it’s highly unlikely that the ‘average’ developer will ever in our lifetimes be able to figure this stuff out.”

That’s just generics. And if you seen the proposed syntax for closures, well its readily apparent, Java’s elastic modulus has been exceeded. A crippled language has been fast marched evolved into a broken language.

Plenty of blame for all here. In the last 50 years academia and commercial entities have given us boutique languages, COBOL, C++ and Java.

A Proper Programming Language For Business Development

It’s the age of the Jetson’s, and a decent programming language for enterprise business applications doesn’t exist.

So lets design one.

Simple, clean and full featured.
Ready of concurrency, distributed applications on mult-core commodity boxes.
Allow for the explicit control of state and state mutation.
Support for modularity, and scaling in the large.
Multiparadigm to support mapping the commonality and variability of the domain problem to the code.
Capable of supporting Application Oriented Language / Domain Specific Language development (AOL/DSL).
Cross platform, with a large supporting tool suite universe.
Open and not subject to Vendor locking.
Fast
OO
Functional
Conceptual Integrity.
Allow control of, if not out right banishment of the null pointer.
Rich libraries.
Strongly Typed
Practical and Pragmatic
Accessible to the average developer, empowering to your A players.
Runs on a portable VM.
Leverage existing extensive Java libraries.

This is Scala.

So How Is It Going

Fast forward… Currently a very small team and myself are near completion of the first major functional component on the JOSH stack.

All of the development talent on the team are experienced Java developers. And they have been effective from Day 1.

No real discussions of covariance and contravariance was required. We did discuss HOF, anonymous lamba, closures, cut syntax, maps, folds, reduces. And strangely their heads did not explode. We did discuss the evil of mutable state, and referentially transparent functions.

They were enthralled.

No detailed lectures on the deep underlying structure of Catamorphism, Anamorphism, Apomorphism, Hylomorphism and Paramorphism was required to get solid code at a cleaner and higher level, with less bloat then equivalent Java.

A core aspect of system is combinator based threading state through a composed computation. No problems in understanding were observed.

In fact in terms of difficulty, they struggled somewhat more with Git then they did with Scala, Linux then they did with Scala, IDEs issues then they did with Scala, and Maven then they did with Scala.

At a minimum they wrote better Java idomatic code in Scala then they did in Java and proactively adopted more idiomatic Scala as time went by.

Visual Basic now has lambda and no one expects a VB developer to throw himself off a building. Yet somehow, these days too many think Java developers can’t handle more advanced functionality.

I’ve seen too much of “I just did this fold thingy and my co-workers could _never_ understand that” is a bit overblown. OK, if they have never seen it before, they might not get it in 10 mins. But working with the team on the basics for 10 hours or 10 days will certainly do it.

But bottom line, enterprise Java developers can transition to Scala. I know this, because I’ve directly observed it.

JOSH has no Data

The JOSH stack is lacking a letter, because a solution for persisted data is missing in the stack.

A great deal of what needs to be done does not require a ACID RDB cluster. Some of it does and I’m kicking that can down the road.

For the rest, either the data is ReadOnly and loaded a 1-3 times a day or is best persisted by a distributed Key-Value storage system. A number of these are now available as open source solutions and at the right moment I’ll need to pick one and add that letter to the JOSH stack.

Google wave is dead

noreply@blogger.com (Razie) — Mon, 09 Aug 2010 15:30:00 +0000

...yeah, the "king of the interactive communication is dead, long live the king".

While enthusiastic in the beginning, I must say that we didn't used it as much as we thought we'd be. The technology behind it however is awesome, but I must agree, the implementation wasn’t the greatest. It should be embedded in google docs and integrated with email and IM. I think I already saw some of that in google docs recently…

For instance click on an email thread and "turn to wave". Or the same in IM, think of it as "persisting the thread".

In google docs, the use of this is obvious: it's turning any doc into a version controled repository, real time wiki with embedded forum etc...yeah, makes sense. Every software MUST now have this: every wiki, every forum, every Word application...they simply must! Getting this question in a flashing status bar of your favorite Word app "Do you accept interactive edit of this document, from John@somegeeks.com?". Hell, yeah...

The "playback" feature was underutilized.

May be surprising, but I used it mostly as an internet pad to copy/paste quotes, ideas, links and later develop them. Also to copy/paste things between laptops/computers, save them for later etc.

An "internet research pad", where you could invite others etc...that I still think it's worthy of its own site.

I will, spare time existing, look at integrating this with my script pad: http://scripster.razie.com/play/session - That would be bespinningly interesting.

As always, don't hold your breath.

Bitching about American Express

noreply@blogger.com (Razie) — Tue, 15 Jun 2010 15:42:00 +0000

So, my Amex card is a little ripped and I call them to send a replacement. They said they'll change the last 4 digits of the card so now I have to update all my online and pre-authorized stuff, banking etc.

I explain that my card is not lost and that's a lot of work. They explain that I may cancel my account instead if I wish. I almost did that...but realized I was pissed and just backed down - I guess keeping a long-standing account is a positive for my credit history.

Anyways. I am updating all my pre-authorized and online stuff to use my MasterCard and I will simply park the new card, when it arrives, somewhere in the library.

Just like that, Amex lost a few hundred/thousand dollars in revenue and all of a sudden I feel good about it. I promise I won't use it anymore...I'll now carry a MasterCard and a Visa instead.

The morons should realize that I don't care about what they want...but, if they want my moneys, they should really care about what I want!

Anyways, bitching accomplished. Feel better.

Cheers

P.S. Their website does not have either an email option or an online form for complaints...nothing online. All they have is phone numbers (but I just hanged up) and snail mail addresses. Oh well - serves them well...they got a blog instead and "lost" a customer.

P.S. Already switched a few monthly recurring payments and online processors to my MC. This is almost fun now.

Blogger is stupid

noreply@blogger.com (Razie) — Sun, 14 Mar 2010 03:04:00 +0000

Trying to edit a blog (this one) I've had it: this editor right here is one of the worst I've used in a long time. It's still close to impossible to quote nice code snippets and the html it generates is riddled with DIV tags worse than a word document.

I guess this is the fate of things. The bad ones become good enough and the good get worse.

Shame. I shall investigate options to blogger, since the best voting is done with the feet...or, in this case, with the...fingertips...?

I shall create my own nice code quoting system, based on the scripster I just put together. I should probably thank them for the idea...

[EDIT] The code quoting is up and running - just need to work on embedding the quotes now. Try it at www.codewitter.com

Implementing a state machine in scala DSL

noreply@blogger.com (Razie) — Fri, 26 Feb 2010 16:17:00 +0000

I had a bit of fun in the past few days writing a telnet server implementation in #scala. Part of that was implementing a state machine, which I then cleaned up so the definitions are simple.

Here's a sample state machine:

The code is at http://code.google.com/p/razie/source/browse/trunk/razie/src/razie/SM.scala

The basic structure is:

 (state, event-matcher) -> newstate + callback ++ unitcalback... + callback :: Nil

The event-matcher can be:

an event

a sequence of events

a function taking an event and returning...Boolean, of course

The callback is a function with either of these signatures:

def push (sm:StateMachine, t:Transition, e:Event) - use + for these

def reset : Unit - use ++ for these (hey, I'm still getting my head around advanced scala stuff)

Enjoy, and if you likee, contribute, eh?

Here's the definition (in-work) of the high-level telnet state machine, a little more complicated but not much.

The picture (thanks to http://tomi.vanek.sk/index.php?page=telnet):

The state machine (when it's ready I'll post the link to the entire code):


// based on diagram at http://tomi.vanek.sk/index.php?page=telnet

implicit val sm = this

val sstates @ (data, cmd, app, param, neg, subneg) = ("data", "cmd", "app", "param", "neg", "subneg")
override def start = state("data")

override val transitions : Seq[Transition] =
     (data, IAC)             -> cmd ::
     (data, 0)               -> data :: // NOP - don't know why i get these after CR
     (data, 10)              -> data :: // NOP - LF ignored?
     (data, 13)              -> data + eatLine + echo ("") :: // CR
     (data, {_:Event=>true}) -> data + eatChar + echo ("") :: // remaining chars
     (cmd, IAC)              -> data ::
     (cmd, Seq(WILL, WONT, DO, DONT)) -> neg + push ::
     // TODO 3-2 should negociate stuff, i.e. reply with will/won't
     (neg, {_:Event=>last==SM(DO)})   -> data + mode(true) + pop ::
     (neg, {_:Event=>last==SM(DONT)}) -> data + mode(false) + pop ::
     (neg, AnyEvent) -> data + echo("interesting sequence...") + pop ::  // What is this?
     (cmd, SB) -> subneg ::
     (""".*""".r, CR) -> data :: // it's important to reset the thing on ENTRE
      Nil

def eatChar (sm:StateMachine, t:Transition, e:Event)
def eatLine (sm:StateMachine, t:Transition, e:Event)

Enjoy and, more importantly, have fun!

If you'd like to read more of my rants about scala, see http://wiki.homecloud.ca/thinking-in-scala

Start dowloading torrents remotely

noreply@blogger.com (Razie) — Wed, 20 Jan 2010 17:48:00 +0000

Say you're at work and you stumble onto a torrent you'd like to watch tonite (some documentary or the latest episode from http://www.cbc.ca/nextprimeminister/blog/2008/03/download_canadas_next_great_pr.html).

Well, here's one way to do it...

1. Run uTorrent at home, 24/7, even if it's not downloading anything. Configure it to automatically load torrents from a folder say "torrentstodo". This is in Preferences/Directories at the bottom.

2. Install LiveMesh both at home and at work

3. map this folder as shared on both computers: right click and say "share with LiveMesh" at home and at work just right click the "LiveMesh Folders" in explorer.

Then, when you like a torrent, save it to the local "torrentstodo" folder at work. LiveMesh will transfer it at home automatically. Then uTorrent will pick it up and start downloading it.

Please don't steal copyrighted material when it's easily available (online) at a reasonable price :)

I'm a Code Manager

noreply@blogger.com (Razie) — Fri, 11 Dec 2009 22:01:00 +0000

Product Manager, Project Manager, HR - i.e. People Manager, Technical Account Manager, Development Manager, Build Manager....and developers. Some develop and the rest manage stuff.

WRONG!

You know what? I want to be called by my new title: Code Manager. Everyone manages something and I manage code.

THERE!

I guess I missed the many architects, we can call them Code Benders - hey, I actually like that!

Happy coding!

P.S. I think I left out the Resource Manager - as in some companies, people are known as "resources". So in a project, the Project Mananger can choose 3 resources: a cofee machine, a printer and a developer. WRONG. I'm a Code Manager, not a resource, so please...

My Nokia 770

noreply@blogger.com (Razie) — Thu, 24 Sep 2009 15:35:00 +0000

I love my Nokia 770 and it's much more useful than the iPod - I must say...Since I was bashing all device manufacturers other than Apple, I must exclude Nokia from the list...

Having the courage to come up with a Linux-based Internet tablet, when they did, puts them squarely in front of Apple...

The thing is that I use them both (iPod Touch and the 770) as remotes to control movie playing at home and the Nokia is better equiped to be the remote. It is a little bulkier and sluggish to reconnect the WiFi, but the web browsing experience is much better, for the simple pages my application requires (larger screen helps, but the ergonomics of full-page and persistent zoom are what make it the better one).

Fully customisable home screen and a host of applications out-of-the-box actually make it the winner...just to think that I've had it for a few years now and it cost half what the iPod did...why is this new iPod touch so backwards? Target market? Well, I guess simplicity does have its benefits...it is a portable music player first of all!

iPods suck nicely

noreply@blogger.com (Razie) — Mon, 21 Sep 2009 16:08:00 +0000

Just gave in and got the new iPod Touch (32G) this weekend. Let's see...

Couldn't even take it out of the box - I was afraid to break it - I went back and asked a "Mac Helper" for help and he explained how to take it out - apparently Apple just won the abnormal packaging contest!

Walked again out of the store only to come back: when turned on, the thing only displays an image suggesting plugging its USB into iTunes. I had to go back and explained that I just paid 400$ for a toy that doesn't work...they finally convinced me to just refrain from returning it and wait until I got home to plug it in and see what's what.

Well - finally got home and started playing with it. It does grow on you and you start to wonder how come every OTHER device manufacturer out there seems to be sooo stupid. They do deserve the market share they're left with!

But then you start to notice the noticeables:
- the only dark screen is the home screen...most others are the same stupid black on white as your microsoft outlook...and there's no obvious way to change the "skin".
- the browser, while smart, is also stupid. I.e. the "zoom", while nicely done with the pinching manouver, is not remembered when you click on the next page
- the home screen doesn't go wide when you turn the thing...non-sensical since when you can go back and forth between "wide" apps, you pass through the home screen and have to turn the thing again...

Overall, they can get away with all these, just because the thing is so nice in many other ways...but it goes to prove the limits of every day life - nobody's perfect.

converting Java collections to scala collections

noreply@blogger.com (Razie) — Thu, 17 Sep 2009 03:50:00 +0000

This took me many hours to figure out. I didn't find a word about it in the (quite a bit of) stuff I read, including the "Programming in Scala" book, blogs, posts etc.

How to best convert java collections into scala collections and back. This is crucial, as lots of would-be scalaistas would still carry around some kind of Java library, be it JNDI or JTA or some in-house non-rewritables!

As of scala 2.7, scala.collection.jcl.Convertions is your friend. As of scala 2.8, scala.collection.JavaConversions is your best friend. Enough said.

Interestingly, I use List pretty much everywhere in my code. However, as you'll see, since List is the only one that doesn't freely convert from one to the other, it follows that you should use Seq[A] in all your scala code...hmmmm

[later edit] Also, your arguably best friend in scala is the scala.collections.mutable.ListBuffer - check it out, it's all you thought List would be! Although, after a while, you will find yourself relying on mutable collections less and less...

To get the full power of the implicit java to scala conversions, make sure you import the contents of the class, note the underscore below:

import scala.collection.JavaConversions._

[Later edit] I removed my examples here as being too clumsy :) use the import above instead.

Increase battery capacity to 123% :)

noreply@blogger.com (Razie) — Tue, 11 Aug 2009 20:25:00 +0000

Just got this "warning" from my own laptop...no comments!

Process Explorer - me likee

noreply@blogger.com (Razie) — Fri, 05 Jun 2009 14:51:00 +0000

Installed this Process Explorer a while back and it replaces the windows classic Task management stuff which is hopeless!

I love it. The best features are:

it shows a lot of information about what's running

you can search for a process just by typing the name

when you say "kill" it actually kills them asap rather than think and wait and ask for confirmation about 10 times...

Whoa! Goodie! Me likee.

Your own newspaper

noreply@blogger.com (Razie) — Thu, 14 May 2009 16:59:00 +0000

Here's the culmination of the freedom from the mainstream: you can create your own newspaper, from the feeds you want: http://feedjournal.com/index.html

Not only are we using feed readers, we can now print our own newspapers - that's so cool...interestingly enough, this is just another of the Sovereign Individual predictions...

And...to complete the picture, for the retarded sites that don't support content feeds, here's a free service that does it: ChangeDetection. It is simple to use and no catches that I could find...

If you're looking, there's actually more of these page2rss services, including http://page2rss.com - really simple! The http://www.watchthatpage.com/ seems more complicated, while http://www.followthatpage.com/ can do only email...

Happy newsprinting!

Optional arguments in Scala

noreply@blogger.com (Razie) — Tue, 21 Apr 2009 16:50:00 +0000

I couldn't find much on the web with this search and it took me maybe 15 min to figure it out, so here's the low down on using optional arguments in Scala. There's a description in section 8.8 in the Programming in Scala book - they call them "repeated parameters".

Using this notation you can overload Java methods with optional parms as well as pass them over to a "super." method (which was what I needed to do):


def takesOptionalArgs (x:String*) = {
   println ("Scala println: ", x.mkString(" "))
   java.lang.System.out.printf ("Java printf: %s %s %s", x:_*)
}

This special syntax instructs the compiler to pass the x array elements individually, not as an array!

Cheers.

[later edit] P.S. Note that there's an outstanding defect for overloading java vararg methods - it currently doesn't work: https://lampsvn.epfl.ch/trac/scala/ticket/1459

Agile Architecture talk from Coplien

noreply@blogger.com (Razie) — Tue, 14 Apr 2009 18:13:00 +0000

For a nice glimpse at the future of programming as it evolves, I strongly recommend this talk from my favorite architecture guy: Coplien. Prerequisites: get a beer, slippers and a robe, the conclusion is not light reading!

http://blog.jaoo.dk/2009/03/04/handling-architecture-in-the-agile-world/

Some of the things that deserve emphasis:

The need that the application’s own model matches the model the users have in their head, i.e. the “view of the world” is obvious, but, unfortunately, it is not obvious to many…

Architecture is the essence of structure (the form), not the structure itself.

A good agile/lean architecture:

supports change

Supports user interaction

Lowers discovery costs, rework

Other memorables:

Habitable code – code where the designer could choose to live. Do you like your code? Would you live with it?

Refactoring is bad! We want to avoid re-work…you need a system view, not code–as-you-think!

The long forgotten purpose of OO is to capture the model from the user’s mind, not create toys for developers!

(Razie says hmm): Do object diagrams instead of class diagrams – users think in terms of instances, not abstract classes.

The GUI is not something between the GUI and the model, is a tool allowing the user to mess with the model! Kent Beck said “you can’t hide a bad architecture behind a good GUI”.

(Razie says hmm): Requirements are the LAST thing you look at when doing architecture!

Need architecture upfront, code just-in-time!

Java is a TOY language.

Scala’s got traits, baby!

This is the brief follow up: http://blog.jaoo.dk/2008/12/20/jaoo-video-2008-james-o-coplien/

Peter Coad’s now a pilot, but his role-based color modeling should’ve taken off!

Components vs Frameworks

noreply@blogger.com (Razie) — Thu, 12 Mar 2009 14:44:00 +0000

ABSTRACT: One of Razie's infamous uber-principles: I see frameworks as being the opposite of components. When architecting parts of a system, use this to decide on one or the other - this point of view could enrich the designer's arsenal of decision principles.
TAGS: architecture, design, principle

When you're talking about "writing code", the best option is generally reusing an existing piece of code and customizing it. Reusable pieces of code are normally in the category of either components or frameworks.

Components are more or less black boxes with well defined inputs/outputs and customization settings.

Frameworks, while they may also have defined inputs/outputs, they generally cannot be used as is. You write "plugins" (i.e. proxies or strategies) that customize a piece of the puzzle and then combine them to achieve the functionality the framework is intended for.

I see frameworks as being the opposite of components, given how they're used: while components are pre-determined pieces of functionality, which you combine to achieve a flexible structure, frameworks define first an immutable structure and then allow you to customize some aspects of it.

Patterns fall sqarely in the framework category, since they prescribe a structure with roles to fill out.

In terms of initialization and configuration, components get everything up-front, while frameworks usually will use a callback to retrieve configuration, when needed. At least it's easier to always follow this pattern: use of factories indicates frameworks, for instance.

Depending on the level you're at and your point of view, it is relative whether a given library falls in either category. For instance, a component could take a "strategy" as an input.

When you look at a system, you will see components made of frameworks, made of components, made of frameworks etc. A system is made of sub-systems, which can only be of either kind :) since they're the two opposite forms of sub-system architecture.

CONCLUSION

Making the distinction and decision between component vs. framework, when designing, is important, since the denomination of "component" carries lots of semantics: independence, self-sufficiency, black-box, upfront initialization etc.

Frameworks allow flexibility in the detail but are inflexible structure-wise. A framework that is too flexible is called a mess.

A framework with all variabilities fixed is a component.

Keep thinking and have fun, eh? I certainly am!

Google Chrome and your passwords in clear-text

noreply@blogger.com (Razie) — Tue, 17 Feb 2009 17:18:00 +0000

It was fun using the "remember passwords" feature until i figured out that Chrome will show your remembered passwords in clear-text...

...it's probably the worse feature I've seen implemented so far, this year...but it's just february...and you didn't see what I have to say about CIRA-the Canandian internet registrar- yet, eh?

[later edit]...this is especially evil since now evildoers could change the passwords to all your accounts and lock you out - otherwise, even if they find your laptop logged into all those accounts, they couldn't change your password before you did...

Design Patterns Quick Reference

jordi — Thu, 16 Sep 2010 12:16:07 +0000

10/GUI

Mike Girouard — Wed, 11 Aug 2010 16:00:01 +0000

Java and Practicality

(author unknown) — Sun, 08 Aug 2010 04:07:22 +0000

Shared by Razie
Java's been this mind-numbing trap that's hard to get out of. All is classes and...well, more classes!

I have found that those who advocate for the practicality of Java as a programming language for solving software problems invariably have an incredibly poor understanding of programming language theory and poor general problem solving skills. However, almost always, an even poorer understanding of the Java programming language itself is most prominent.

Consequently, one cannot have a reasonable discussion about the merits of problem solving, using the Java programming language, or programming languages in general. However, one hopes that this sample set is biased and so one continues the search for a counter-example.

This is lamentable.

The Best Way To Charge Your Phone

Cheezburger Network — Thu, 05 Aug 2010 17:00:28 +0000

Submitted by: Unknown

Favorite Comment: treborx says, “message(s) in a bottle. WIN!”

Bionic Dick Cheney Technically Has No Pulse

Clay Dillow — Mon, 19 Jul 2010 21:29:16 +0000

Are We Living Inside a Black Hole?

Rebecca Boyle — Fri, 23 Jul 2010 15:53:37 +0000

What's Ahead In The Clouds?

Jack Loechner — Wed, 14 Jul 2010 20:30:28 +0000

Less.js Will Obsolete CSS

Dmitry Fadeyev — Sat, 19 Jun 2010 00:00:00 +0000

If you design websites you may have heard of interesting tools called CSS pre-processors. A couple of great ones are LESS and SASS. I helped Alexis, the creator of LESS with the design of the language and built the public site.

It’s a tool I wanted to use myself, and even though SASS already existed I didn’t feel like using a different syntax to CSS—I wanted something to augment CSS and make it more powerful, while still retaining the same look and feel. That’s exactly what LESS does. It extends CSS with things like variables, nested rules, mixins and operations to name a few.

Here’s an example of LESS code to give you an idea of what it does:

@brand-color: #3879BD;

.rounded(@radius: 3px) {
    -webkit-border-radius: @radius;
    -moz-border-radius: @radius;
    border-radius: @radius;
}

#header {
    .rounded(5px);
    a {
        color: @brand-color;
        &:hover {
            color: #000;
        }
    }
}

Three features in use there. First of all I’m specifying a variable at the top called @brand-color. I then re-use this color for a link. I make a class called .rounded which I then use for the #header div (the header will take on all the properties of the rounded class and use 5 pixels instead of 3). You can also see nested rules in use, which really help make the code more organized. Learn more about LESS over at the official site.

LESS was originally coded as a Ruby gem. No specific reason to use Ruby other than it’s a great language and the gem format is easy to use on *nix machines (Linux, OS X)—tools of choice for many web developers. You didn’t actually have to use Ruby or know any Ruby to use LESS to process your code, you just had to have it installed, but even so, this puts many people off who are not familiar with what Ruby gems are or how to use them. There’s now LESS implementations in other languages, including PHP and .NET.

Less.js

Very soon we’ll see the next evolution of LESS. The new change will be bigger than any previous implementation or update because LESS has now been re-implemented in JavaScript. What this means is you no longer need Ruby, ASP or PHP to use LESS, you just need a browser.

Less.js is a JavaScript implementation of LESS that’s run by your web browser. As any JavaScript, you include a link to the script in your HTML, and…that’s that. LESS is now going to process LESS code so instead of including a link to a CSS file, you’ll include a link directly to your LESS code. That’s right, no CSS pre-processing, LESS will handle it live.

Wouldn’t live processing lag? Not really. Two reasons for this. One: Less.js has been written from the ground up for great performance, so even browsers with poor JavaScript implementation should still run it very well (Less.js is about 40 times faster than the Ruby implementation—so suffice to say it’s a lot faster.). Two: On modern browsers that support HTML5, Less.js will cache the generated CSS on local storage, making subsequent page loads as fast as pure CSS.

There are other cool features built into Less.js. For example, there’s a “watch” feature available in development mode. This feature will refresh the CSS on your page whenever your .less file is saved with new changes. The best thing is, it won’t refresh the whole page, just the right bits of CSS, live.

I’ve been using Less.js on my latest redesign of Workable that I’ll deploy for production soon, and it’s been a fantastic experience because all of the above really does work.

Sneak preview

Alexis hasn’t officially released Less.js yet, but…the repository has been up on Github for a while and you’re free to grab the latest release and try it for yourself (and he’s given me permission to blog about it). I think you should, because Less.js really is a big deal. Here’s the repository.

Note that Less.js is actually a Node.js implementation as well as the client-side browser based one, so most of the files in the repository are irrelevant if you just want to use the browser one. What you need is either one of these (the min file is minified for smaller file size)

Try it now

That’s the Github repository, but there’s also a Google Code repository where you can get just the browser script. You can do something really simple and link to the file on Google’s server directly, so if you want to try out Less.js now include this in the head of your HTML code:

<script src="http://lesscss.googlecode.com/files/less-1.0.18.min.js"></script>

Now, to use LESS code, include the .less file as you would your .css but provide a rel="stylesheet/less" property to tell the LESS compiler that it’s a LESS file. Include this above the JavaScript:

<link rel="stylesheet/less" href="/stylesheets/main.less" type="text/css" />

Just make sure the href="/stylesheets/main.less" points to the location of you .less file, and you’re good to go. Code your LESS and and it should magically render in your browser as if it were CSS.

NOTE: Make sure to put the LESS include before the JavaScript. So putting it together should look like:

<link rel="stylesheet/less" href="/stylesheets/main.less" type="text/css" />
<script src="http://lesscss.googlecode.com/files/less-1.0.21.min.js"></script>

It need not be said that Less.js development is ongoing and this is a very early release, which means you might just run into a bug or two. Having said this, my experience so far has been very, very positive, with no parsing errors at all. Also, if the compiler runs into any problems you’ll get an informative error message in your browser telling you where the problem in your code lies.

This is very exciting stuff, so if you’re looking for a way to get your large stylesheets under control and make the CSS design process more effective you should definitely give LESS a shot.

P.S. To use the live “watch” feature (which will auto-refresh the CSS whenever you save your LESS code), just drop this code into your template:

<script type="text/javascript" charset="utf-8">
    less.env = "development";
    less.watch();
</script>

You may not even need the “development” line because the script should detect when you’re running on a local machine, but it didn’t do it in my particular case so I’m setting it manually. Another method to invoke watch is to append “#!watch” to the end of your URL.

P.S.S. Less.js browser script currently won’t work if you’re using Chrome and the path to your page starts with “file:///” due to a known Chrome issue.

NASA/JPL Launch DSLs in Scala

bagwell — Sun, 20 Jun 2010 01:42:20 +0000

Guardians "Open Platform" Uses Scala

bagwell — Thu, 17 Jun 2010 02:00:39 +0000

Every Sitcom Uses The Same Newspaper

GOB BLUTH — Sat, 05 Jun 2010 17:28:46 +0000

Wtf.

DIY Sun Tracking Solar Panels

Saikat — Mon, 24 May 2010 09:32:02 +0000

For a photovoltaic solar panel, following the sun’s path across the sky raises efficiency by 30-50%. This DIY sun tracker is the latest addition to our DIY Free Energy projects and uses a combination of a sensor and linear actuator to track the movement of the sun.

The solar panel sits on a wooden frame which is mounted on two bicycle wheels. A sensor tracks the path of the sun and sends the signal to the liner actuator that starts moving the photovoltaic frame with the help of the wheels.

After sourcing the solar panels, the solar PV tracker is not difficult to build. 12 Volt linear actuators are available on eBay. Then, just salvage a pair of strong wheels and all that’s left is the wooden frame.

Popular Solar Energy Projects:

A periodic table of visualization methods

jordi — Wed, 02 Jun 2010 09:20:13 +0000

ConceptDraw MindWave mind map tool brings important visual element to Google Wave

Chuck Frey — Thu, 04 Mar 2010 19:09:22 +0000

CS Odessa, the developer of ConceptDraw MINDMAP, recently announced the availability of a free extension for Google Wave, ConceptDraw MindWave, that enables users to create visual maps within Google’s exciting new collaborative environment. This neat tool brings an important visual element to collaboration within Google Wave, which is almost 100% text based.

Using MindWave, you can easily insert a new map into your wave, invite others to collaborate with you and then co-edit it in real time.That means you can use it as a tool for planning simple projects and for small group brainstorming.

MindWave supports Wave’s playback function, which enables you to see how a mind map was constructed, and who added what content to it. This is ideal for new users, who may not be familiar with mind mapping.

Mind maps built within MindWave can be downloaded and developed further using CS Odessa’s ConceptDraw MINDMAP software for Windows and Mac OS X.

Thankfully, MindWave supports a number of keyboard shortcuts, including:

Shift+Enter to add a new topic.
Double-click on a topic adds a sub-topic.
Paste a word or phrase to add a new topic.
Paste a column of words to add many topics at once.
Drag and drop organizes your mind map.
Press Delete or Backspace to remove a selected topic.
Arrow keys navigate you through the map.

I added MindWave to a wave in my Google Wave account, and found that it installed easily. Creating a new map and adding topics to it was also a breeze; it behaved exactly as I would expect it to. The shortcut keys are non-standard, but then again you’ve got to remember that you’re working on an extension that has to play well within another, larger application. So CS Odessa had to select hot keys that don’t interfere with Wave’s functionality.

The only limitation I foresee with MindWave is that the maps you create within it must, of necessity, be fairly simple. You’re constrained in terms of space to only one-third of the browser – because the other two panels are used by Wave for managing waves, folders and users.

Still, MindWave is a great little applet that is stable and intuitive to use. Kudos to CS Odessa for taking the lead and producing this neat little application to support one of the web’s most compelling new collaboration tools.

TEDTalks : Gary Lauder's new traffic sign: Take Turns - Gary Lauder (2010)

(author unknown) — Tue, 09 Mar 2010 14:39:00 +0000

Absolutely Ingenious Wooden Rube Goldberg Machine

Saikat — Sun, 14 Mar 2010 00:00:53 +0000

The Marble Lifting Machine would probably impress even Leonardo da Vinci. Mere words cannot describe the play of physics and craft that goes into this machine which has a single task â€“ take a steel marble and transport it to the top of the wooden structure, then to the bottom, and repeat for 24 hours without any electronic parts.

Don’t Miss: Top 7 Incredible Rube Goldberg Machines

That’s right, the only power is provided by gravity. The initial impulse is provided by a system of weights and counterweights. A complex network of wooden channels, lifting devices, pulleys, and trapdoors keep the marble in almost perpetual motion. The smooth flow of the marble towards the top is kept up by a series of governors and escapements.

Itâ€™s quite a journey for the marble up and down the 6 feet tall wooden device (a complete circuit takes about 24 hours). The marble makes 1300 trips from the bottom to the summit and back again and travels an equivalent distance of 12 miles. Â Â The video is not only about the motion but also how the sub-assemblies of the Marble Lifting Machine are put together. It’s science wrapped up in art.

Top Rube Goldberg Projects:

The Enso zenPad MID banks on being the cheap Android tablet

(author unknown) — Tue, 23 Mar 2010 01:25:16 +0000

Shared by Razie
Cool - apparently we can actually by this now!

Here’s another firm contender in the small tablet market. The Enso zenPad comes in with a 5-inch 800 x 480 resolution touchscreen powered by a Samsung 6410 667MHz processor. It also starts at an affordable $155 and is currently shipping. This isn’t the first we’ve heard of the Enso zenPad, but it has had a name [...]

Robert Fischer Finally Admits that Scala is Functional

James Iry — Mon, 08 Mar 2010 15:40:00 +0000

Kojo - Scala for Kids

(author unknown) — Sun, 21 Mar 2010 15:08:43 +0000

Shared by Razie
booya - kudos, been looking for this kind of stuff for while, having it in scall is awsome

Kids love computers and many would love to learn how to program them too. Lalit Pant, volunteer Math teacher at Himjyoti School for under-privileged girls in Dehradun, developed Kojo in his 'free' time. Kojo is a very polished, easy to install, cool IDE in which children, (or even grown ups) can learn to program using Scala. Lots of examples, a turtle to drive, good documentation and interactive geometry for those budding mathematicians. If you have kids then Kojo could be a fun experience to share with them. On the other hand if you have some 'free' time Lalit would welcome help to develop Kojo, an Open Source project, further.

Distributed Version Control is here to stay, baby

Joel Spolsky — Thu, 18 Mar 2010 00:25:54 +0000

Killing an annoying warning

noreply@blogger.com (Razie) — Mon, 29 Mar 2010 00:23:00 +0000

The most annoying warning ever has been haunting me for a while.


    [javac] /home/razvanc/workspace7u6/razxml/src/razie/base/data/RiXmlUtils.java:160: warning: com.sun.org.apache.xpath.internal.objects.XObject is Sun proprietary API and may be removed in a future release

I refuse to include and move around large unnecessary libraries to deal with XML and XPATH just because Sun considers themselves the center of the universe and their internal libraries somehow more important then mine. In short, they figured there should be no way to remove this warning, although, in this case, they copied code from apache into their own libraries.

Well, the solution is rather simple. Most likely everyone has specific XML wrappers. Just put them in their own project, disable the java/scala builders. Then, build it manually, create a jar file and check it in.

Then, in all the other projects, use this jar directly. Since the jar is already compiled, the annoying warning is no more.

See for instance my xml utilities, at http://github.com/razie/razxml

What's more, I don't actually use the XML stuff directly. I wrapped it all in pretty much one single class, using XPATH for access. It's simple, fast enough and makes for very simple code:


Reg.doc(MediaConfig.MEDIA_CONFIG).xpa(
  "/config/storage/host[@name='" + Agents.me().name + "']/media/@localdir"
)

For all xml data access, you should limit yourself to the xpe/xpl/xpa methods described in an earlier post (http://blog.homecloud.ca/2010/02/one-xpath-to-rule-them-all.html). So, use something like this instead: http://github.com/razie/razxml/blob/master/src/razie/base/data/XmlDoc.java

Cheers.

The Option monad pattern thing

noreply@blogger.com (Razie) — Sun, 14 Mar 2010 01:00:00 +0000

Having options is cool...even scala's Option[A]... :)

One way to use Option is plain:

addressMap.get("John") match {
   case Some(addr) => popupMap (addr)
   case None => logError(...)
}

or "java style" (synonym with "plain ugly"):

x = addressMap.get("John").getOrElse (null)
if (x != null) {
   popupMap (x)
} else {
   logError(...)
}

As you use scala more, you understand why monads are elephants and start doing it nice:

addressMap.foreach (popupMap(_))

addressMap.map (_.city)

And then you start to understand it as a pattern, basically you understand there's a range of problems were options apply. Say you create a small scripting framework (the same applies to say a command pattern framework). A script's execution may return successfully and with a value, or give a syntax error or a bunch of other options.

// the result of running a smart script

  class RSResult { 
  def foreach (f:Any=>Unit) {}
  def map (f:Any=>RSResult) : RSResult = RSUnsupported 
  def getOrElse (f: => Any) :Any = f
  def jgetOrElse (f:Any) :Any = getOrElse(f)
     }

  case class RSSucc (res:Any) extends RSResult { 
  override def foreach (f:Any=>Unit) { f(res) }
  override def map (f:Any=>RSResult): RSResult = f(res)
  override def getOrElse (f: => Any) : Any = res
     }

  case class RSError (err:String) extends RSResult
  object RSIncomplete  extends RSResult   // expression is incomplete...
  object RSUnsupported extends RSResult // interactive mode unsupported
  object RSSuccNoValue extends RSResult // successful, but no value returned

And then, of course, the methods returning these:

I used Any instead of [A] for simplicity, but there you have it. The Option monad pattern thing. Pretty cool!

Scripster - interactive scala REPL using telnet, http etc

noreply@blogger.com (Razie) — Tue, 02 Mar 2010 01:59:00 +0000

As mentioned before, I think that all apps must alllow scripted/programatic access to their objects.

I created a simple interactive gate to acces the scala REPL in any scala process. It only uses one port and supports telnet, http and swing:

The graphics are based on my 20widgets project, with the addition of a ScriptPad widget.

Content assist is only available in the telnet version (sic!). I will work to find some nice syntax-colored controls for the web version. Switch to character mode ("mode character" on ubuntu or default on windows) and use TAB to see a list of options. Right now it's a demo only, I need to find the parser's APIs to get the real content assist options ;)

You can download the single scripster-dist.jar file from my razpub project download, at http://code.google.com/p/razpub/ and run the example with this command line (replace /host/bin/scala with your $SCALA_HOME) :

java -classpath ./scripster-dist.jar:/host/bin/scala/lib/scala-library.jar:/host/bin/scala/lib/scala-compiler.jar:/host/bin/scala/lib/scala-swing.jar razie.scripster.JScalapSwing

To use it in your process, put these jars in your classpath and use this:

razie.scripster.Scripster.create(4445)

where 4445 is the port you want to use, see the razie.scripster.MainScripster for an example. To enable the swing version, use the swing jars as well and see the razie.scripster.MainSwingScripster class for an example.

For further tweaking, look at the code yourself, at http://github.com/razie/scripster/tree/master/src/razie/scripster/

If you want to keep in touch with the evolution of scripster or my other related endeavours, subscribe to the RSS feed or twitter/razie.

Scripster's main page, kept up-to-date, is at http://wiki.homecloud.ca/scripster. There's also an online live demo at http://scripster.codewitter.com.

Enjoy!

One XPath to rule them all!

noreply@blogger.com (Razie) — Sat, 06 Feb 2010 17:32:00 +0000

ABSTRACT: there's a million ways to access (data, objects, tables etc) these days and probably new ones are created every milisecond. What if we can figure out one that can be used anywhere?

Think about it!

/Universe/Planets/Planet[@name=='earth']/@position

XPath was created as a natural way to address elements in an XML document. One specifies the path - starting from the root node - to the element you are addressing. Conditions help you select the right nodes from many (lists) and you can address nodes or their attributes.

Extending it to addressing trees is strait-forward, so we can apply the same paradigm to any tree-structure, like Java beans...see for instance this Apache library: http://commons.apache.org/jxpath/

Come to think about it, all direct acyclical graphs fit in the same category...of course, with small differences: selecting an edge from among many possible types and lack of a root...so, some extensions are in order:

/Person[@name='John']/{hasFriends}Person

What hapens here is that the node of type Person that meets the criteria was selected as the start node and then the graph walk begins. From the many relationships tying humans together, the ones of type "hasFriends" are followed and not "hasChildren".

Yeah, you got it - even cycles are handled this way simply because as the path is walked, it reaches an end...

And... yeah, you got it again: UML domain model of classes with associations...it can describe any model you may use internally or present to clients...so we can handle pretty much any domain model described in an UML class diagram.

There.

I found myself needing four basic operations:

xpe : T - /** find one element */
xpl : List[T] - /** find a list of elements */
xpa : String - /** find one attribute */
xpla : List[String] - /** find a list of attributes */

For the sake of being concise, I will represent this new "data access interface"as either of the versions below (with explicit type and start node or implicit):

val me = XP[Person] xpe ("/Person[@areGroovy=='yeah, baby!']") from john

val minime = xpe ("/Person[@areGroovy=='yeah, baby!']")

So, why would this be useful?

Frankly, I'm growing old(er) and tired of all the non-sensical APIs that pop-up all the time everywhere: My application is unique! My domain model is complex! Everything could be an Object, but so what? I'm smarter! I know better!

My answer is: nope, your application's domain model is a class diagram and your actual objects thus form a graph. I don't need you to inven new ways to interact with your objects, over a million protocols and a million forms, when we can unify it all.

It's a very simple pattern. All it requires is that users understand basic modelling and the application's domain. The same expressions would be used by everyone...if not, at least the same pattern. No more gazillion interfaces and gazillion models.

Think about communication. Can be done in 2 ways:

1) blah blah blah can blah blah when blah blah and then some more blah blah

2) UML

You give me your domain model and, since you implement this simple no non-sense path-based model access, that's all I need to know. What you should focus on is documenting what the actual objects in your model: what they mean and what I can do with them once I have them.

This also enables generic graphical software creation. All I need is to have your domain model and then I can use a generic path composition tool (pick a node from a tree if you want).

It interactively explores the domain model, picking elements on the way.

In my integration work, I would love it if I didn't have to waste time writing stupidifying code over a miriad protocols just to get to what I needed.

If you're wondering how exactly the data should be accessed, we'll cover that in one of the next posts on this subject, in the mean time, take JOSH to heart: JSON, OSGI, Scala, Http...thank you, Gray Lens Man!

Enough for now - will continue soon...if you're interested and impatient, you can play with my prototype at http://github.com/razie/razbase/blob/master/src/razie/XP.scala

Counting the lines of code in a project

noreply@blogger.com (Razie) — Tue, 15 Dec 2009 21:56:00 +0000

cd ~/src
find . -name "*.java" -exec wc -l {} \; | awk '{ SUM += $1} END { print SUM }'

this is cool...

One Person

noreply@blogger.com (Razie) — Tue, 03 Nov 2009 17:54:00 +0000

Abstract: You are one person, using multiple devices - why shouldn't your stuff follow YOU rather than the device? Since we don't like depending on a 3rd party, the "home" cloud is the answer?

--------- Issue

Most programs today are isolated islands of functionality. The Web 2.0 transforms that, allowing you to mesh together pieces of functionality and information. The same is not true on personal computing platforms i.e. your laptop.

The bookmarks you store on your laptop can't be accessed when you're on the desktop at home and vice-versa. Same for your notes and pretty much anything, unless you manually copy them etc.

Option 1: store information on the web (centralised location). The one benefit of this is the ability to use that information from anywhere and any device. The drawbacks include big-brother and relying on a 3rd party for availability (including backup etc). Of course, the need to be online...although smart solutions can use local caches.

The big brother issue is getting worse. As much as you trust ALL levels of government of ALL countries that may have a claim on you or your property AND all their agencies, there are more and more corporations that mine all kinds of data about your person, for different reasons. Some as benign as offering you a new credit card and some as bad as credit recovery, setting insurance premiums etc. Let's not forget identity theft.

Option 2: use a home server. Basically, almost everyone has by now a server at home, which is constantly connected to the big Cloud, whether you're downloading movies or host your own blog. Why not use that instead of a 3rd party, to serve other stuff.

There are many a solutions to host your own stuff and access/share from/with the world. There's lots of software to serve security camera feeds, TV programs from your home, the Windows Home Server etc...the trend is already in place.

Having resolved (somewhat) the big brother and 3rd party dependency problem, there's still the issue of needing to be online.

Option 3: fully distributed and synchronised personal cloud. Store information locally, on the device that creates it (like on the work desktop where you save a favourite) and synchronise all devices (peer-to-peer or properly distributed solution). The only drawback is lack of on-demand availability of the information from other devices, until the sync occurs. This can be solved however by connecting your own PC to the net...or combining with option 1 or rather 2.

------------- Vision

The vision is that of you and your information following you. In fact it's not following you...it's just "there" for you to use. Whatever computer in your "home" cloud you use, your information is there.
I mean, will you upload ALL your favourites on facebook, just so you have them available in the living room, when you get home? I don't think so!

The solution is the logical conclusion of the same debate of distributed vs. centralised that's been raging for the past few decades. All those "in the know" know that it's a wave function. Now we may be heading towards the climax of centralised internet based clouds, but, as more PERSONAL processing power becomes more online, split between more types of personal devices and connected, the trend in the other way is just a matter of time...wave, right?

So, I dream of many agents, running on many personal devices, connected in your "personal" or "home" cloud, sharing all kinds of information and cooperating.

So, when you mark a "favourite" on your work desktop, it automatically gets replicated on your laptop, your home desktop (the cloud's gateway) and all the computers in the house, including the one in the living-room. There's nothing left to do but, when you get home, sit down and enjoy it on the big screen!

No 3rd party knows you enjoy that hardcore woodworking show or that you're trying to fix the toilet seat, no insurance company can mine that you once watched 3 illegal races on youtube etc...all usually available on your facebook or whathaveyou.

-------------- The social aspect

Today, no application is complete without considering the social aspect. You could obviously push some of your favourites to facebook, or share with friends in "friend" clouds.

-------------- Flexibility, customisation

Probably the biggest gain from a "central" cloud, like gmail etc is flexibility and customisability. Gmail is gmail is gmail. That's exactly what it does and, while you may change it's fonts and even access it remotely via an IMAP or http API (thank you, Google) that's still exactly what it does.

A personal cloud, though, can be customised. You decide what it does and how it does it.

-------------- try it

If you want to play with such an agent, try a preview of mine, at http://razpub.googlecode.com/downloads

Read more about it at http://wiki.homecloud.ca

You can even try the remote favourites sharing prototype...follow this link after you downloaded, installed it and started it on several computers: http://localhost:4444/mutant/capture.html - After capturing, go to another computer in your home cloud and see the links at: http://localhost:4444/mutant/asset/Link

This is written as of version 0.x so the links may change - the use case however will be maintained up-to-date in the wiki, at http://wiki.homecloud.ca/savedlink

Modern Applications

noreply@blogger.com (Razie) — Fri, 02 Oct 2009 12:53:00 +0000

ABSTRACT: today it is unacceptable to have any application built as an independent islands of functionality. It is necessary to expose functionality via simple protocols (http).

Really, it is unacceptable today to have any application built as an independent piece of functionality. No application is or should be complex enough to do EVERYTHING. Thus, since we do not view our users as the mandatory human servers of the omnipotent computer -- with the noble lifetime goal of clicking through the menus, dialogs, wizards and buttons that the all-mighty programmer has imposed on them -- all application components NEED TO OFFER API-based access to a basic set of services/functions/objects/whathaveyou.

These span a large number of functional areas, from controlling the application remotely, scripting its behavior, input/output/logging etc, so we'll take them one-by-one in future posts.

Point being that applications become interoperable and subject to automation. There's no other way really to automatically turn down the volume of the DVD player because you answered a call on skype! OR have a tweet on your cellphone when the torrent has finished donwloading the latest CBC show.

--- Interoperability == standardisation?

This thinking is normal to any Unix hacker, since they allways did "find|grep|cut|wc|sort" but it seems too complicated for anybody else to comprehend, especially window-heads.

With physical devices, standardisation is, granted, not easy. Standards arise from a need which is already fulfilled by existing devices, cables and plugs. Then the plugs get standardised and devices become interoperable.

The same was true in the software world (find|grep), but it's been false for a long time, especially since the advent of the stupidifying mouse and the un-parseable pixel.

Command lines have always been around and http has also been around for a long time. There really is no reason not to combine both, when all you want is users to use the functionality your code has to offer.

Ideally, all applications would be certified as "open" and "interoperable" and we will get there, in time. DLNA/UPNP is an example of such an interoperable framework, including certification. So is OSS/J (a set of telecom APIs) and others.

--- using http at rest to describe and interact with the object-oriented world

So, what should ideally happen? We'd have unified protocols for access and interoperability. HTTP, telnet, command lines come to mind. Formats are also an obvious need: HTML/XML/JSON/text. Let REST dictate how things work, but only a modicum of human intervention can be mandated.

Beyond the needs, there's the wants. We'd like that each would expose their internal models (objects, services, methods, actions, functionality) in a standard way, parseable and understandable by others.

If you extend that to the interoperable web, you get the semantic web. Well, almost, since that's been designed by DBAs - they'd like to call it the "data web" and hide logic in a view that offers more data :). Sorry, couldn't help it!

I live in a world surrounded by objects I'm interacting with. Data/information has a very important role to play, but it's not the end-all. My newspaper can not only filter for me the latest developments on that accident, but can also manage my account and micro-payments. Having knowledge of an intermediary PayPal only serves to confuse me and keep my mind busy with concepts I don't care about, since i already told my "gate keeper" that I trust my newspaper somewhat...

The semantic web guys have it right, though. Exposing standardized schemas of the applications's objects and functionalities is the way to go. Scoping these (my "train" is different than your "train") makes obvious sense (think namespaces).

---- So, vat do you vant?

In the B2B universe (now turned SOA) there's lots of WS-based standards, including security, identity exchange etc. These don't bode well on the web, though. Why write things twice? It has to be simple-over-http. PERIOD, dumby.

So, each modern application has:
- embedded http server
- exposing functionality/internal models etc
- designed to be interoperable

I would like everyone to stop buying and using any application that doesn't meet these criteria. Harsh, but then i'm in a bad mood today...

------ So, what's a developer to do?

Embed an http server. In case you need a small, lightweight embedded web server, checkout my public project at http://razpub.googlecode.com . There's lots of others out there - actually I recommend you get one that supports the servlet standard and you do servlets.

Think about and define your business model, spell out your domain entities. Use less services and more objects when defining your API and bode nicely with REST.

Define your model in whatever format you want - just make sure it's an xml file :). We'll deal with these in a future post, but for now it must be objcet-oriented: each 'class' has 'attributes' and 'methods'. The methods have a name and a list of arguments. Keep all types to String for now...assume all interaction is via URLs, which can't marshal bytecode - that's something we'll have to deal with.

Offer access to the entire business model via http, including content (values) and control (invoked methods).

Document all this very nicely in an embedded set of html pages. No smarts neccessary. Simple solutions always work better than complex ones.

If you're looking for an asset/modelling/http object interface framework, checkout the com.razie.pub.assets package of my razpub project.

Stick to the REST principles for now, until my "REST is bad" post is posted.

Modularity - allow extensions of functionality. Since the future is OSGi, may I suggest an OSGi compliant server - mine will be but it's not.

And generally, don't forget to have fun!

P.S. Just to give a concrete example, the VLC player is a great one. It has several interfaces, including telnet and http and you start whichever you want...

What's up with the home cloud?

noreply@blogger.com (Razie) — Thu, 04 Jun 2009 15:58:00 +0000

ABSTRACT: An abstract description of what I'm up to here.

I am generally frustrated with the state of software - and have been, for a long time. People love to reinvent the wheel all the time, make life miserable for the users that don't stick to base use cases etc.

I have some suggestions on how applications should be written and how the (software) world should look like. This is of course just one of the directions in which we could evolve but it's the one that seems to me to make the most sense.

There are quite a few components to this picture so you'll have to bear with me over the course of several separate blogs on related topics and, at the end, we'll put everything together.

There will be three different levels of this new "architecture", bottoms up:

1. The basic idea is that there are certain things that are necessary to include in ANY software component of any kind, for instance exposing an API to access and manage the internal objects, data and functionality.

2. A generic distributed application support framework will then use these to generate the "home cloud" - a cloud of interacting devices and objects under your personal, direct and total control.

3. From here, moving to the web, you can have clusters of clouds of different functionalities, completely removing the necessity for centralized software.

4. On top of these, there are different functionalities and specific use cases, such as "using identities", synchronizing files etc. I am not happy with the way these are handled by existing software, so you'll get a chance to hear my opinion.

It will take me a while to put each into words and sample code. I'm not just blogging here, I'm also putting together a framework to test all these concepts, hopefully good enough that it will be used by others. You can get a glimpse and keep tabs on that here http://razpub.googlecode.com

I will try to blog at least once a month, so a somewhat complete picture will form this year, but don't hold either your breath or me to it.

Intended audience: mixed. The blogs are individually searchable, so a personal review of the "Windows Live Sync" for instance will benefit anyone searching for that kind of stuff. I will try to categorize each blog, to benefit the followers.

I tend to be terse, so be ready to fire up your brain and read between the words. Non software-development professionals may have a hard time with my terseness and techie wor(d) games...they'll figure it out fast and stop reading.

I think that's all for now - I'll end this here and start working on the next month's blog.

Have fun!