Tuesday, April 30, 2013

TwitterSphere play by play

Tweeters that want to do play by play tweeting should have dedicated hash tags or user accounts. I don't need abc news RTing Diane Sawyer et. al.

Opinions I wish I had heard before my first child was born


It's April 30th 2013 and so it's car buying season. But here is the advice I wish someone had given me.
  • buy the car do not lease
  • buy the car with the most accessories but not all the accessories
  • get the car with the DVD entertainment system from the factory
  • Get the van like an Odyssey and skit the SUV
Here's why:
  • we are way over out 15K miles our year
  • there is an ROI value that is calculated based on accessories. Too many accessories and the formular degrades.
  • The after-market DVD entertainment system is crap, not integrated into the car properly, uses RF instead of AUX, no zone control, a different warranty altogether and needs to be in working order to satisfy the lease.
  • The van is just so much easier. It becomes a real people mover. The car seat in the SUV turns your 8 passenger Volvo into a 3 seater. Car seats are wider than you think.
*sigh* anyone else with a bright idea?

First Emberjs vs Angularjs confusion

Ember does the auto active trick when connected to bootstrap nav. You gotta do it yourself in angular. While angular is full of choices which I need to code; ember is highly opinionated but no code for me.

Thursday, April 25, 2013

search for angularjs with multiple views per page

I have been trying to find an example of a SPA (single page application) where there are multiple ng-view(s) but every result from google is effectively non-responsive. The titles match but the content does not.

Sunday, April 21, 2013

The downside of a one page app with a rest backend

Anyone could replace your app with one of their own if the one page app were exactly one page.

My Next Framework

I have been reading everything there is to read on the different architectures for building scalable web applications. The challenges are numerous. For example; the benefits of client-side one-page application is offset by the fact that they lowest entry point smart phone and similar appliances are not as performant as they once were. But then millions of uniques a day might have a similar effect on the server-side of the architecture.

So what to do?

(a) by building a proper idempotent stateless REST layer that can either be exposed via an API layer or buried inside your domain would seem to be a good starting point. This is going to let you scale the backend separately from the frontend with few wasted cycles in between.

(b) when building the one-page app use tools that limit your exposure whether the rendering takes place inside your servers or is pushed to the client. For example using template tools like mustache which are supported in a number of different languages like C#, Go, Java, Ruby... etc. But the real trick might be to implement on JavaScript and use NodeJS. But keep in mind that transitioning from a one-page client app. to a server-side app is not without it's challenges. Currently there are no tools that span the gap; you're on your own there.
My latest endeavor has me capturing system events from applications, forwarding to graphite, rendering results, capturing test case configuration and test results, and many other build and test metrics. I'm never going to be overrun with users but since I need to expose REST calls for the various systems to publish to... it made the most sense. Also since we are all using state of the art computers the only issue might be lag time to download the javascript. (which is not really an issue all things considered). One additional proof of concept is providing data for status board (from Panic.com).

So for now this looks like the simplest way to divide the work. Test the functionality, accuracy and scale. Add features without dependency on having to update the entire source tree.

If the #1 rule is DRY then the #2 rule is KRIS (Keep RIsk Small).

Saturday, April 20, 2013

Irrational Fear of Ruby when working JavaScript

I'm trying to find a good javascript client framework that I can use against a REST backend. I like many of the ideas in Ember including it's routing and embedded handlebars. But I seem to have this innate fear of ruby when it comes to this project. It just feel unnatural. Less and CoffeeScript seem more natural.

Wednesday, April 17, 2013

CQRS Is Proof That Sock Fairies Exist

I suppose that everything needs a name and an acronym... but CQRS? Really? Just reading a few articles on the subject it seems to be too verbose. (a) there is CRUD and then; (b) there is CQRS. And it's also important to note that CRUD is CQRS but that not all CQRS is CRUD.

The thing is we all experience CQRS almost every day as not all architectures are CRUD. For example in systems where network traffic/payload/protocol needs to be optimized by reducing many-to-one transactions or when refactoring the backend DB for whatever reason we tend to encapsulate the CRUD within CQRS.

Monday, April 15, 2013

Google go has a downside

Watching rob pike's presentation increases my respect for go but I struggle with production deploy best practices.

Forking github projects

The next time I build a project with a dependency on a project in github or bitbucket I'm going to fork it to insure it's always available.

Product idea

I just started an incremental backup with apple's time machine. I wish it would send progress updates to my phone.

Saturday, April 13, 2013

NodeJS servers to support one page aps

I've tried a number of NodeJS servers [expressjs, sails, meteor, hapi]. I cannot say that they are all completely different or that they are completely the same. They are what they are.

  • expressjs comes from a long line of connect experience.
  • sails feels a lot like rails with some really cool features like auto subscription, socket.io, and the browser console.
  • meteor is a complete departure from the others. It's a complete server but it's also a complete platform. More so than the others. It's also it's downside. It already includes bootstrap but what version? Then there is the customizations too.
  • hapi is an odd duck. It's like a traditional app server but then they go a long way to help you handle some of the edge cases like client ans server side cache with a simple config setting. But then when you look at the add-ons they are so very incomplete.
The documentation and useful examples are another pain point:
  • expressjs the documentation is just barely adequate when supplemented with the code. But then the examples could be better.
  • sails has a great screencast but the documentation is missing some key elements like how to deal with static docs. While you're likely to figure it out you may feel abandoned.
  • meteor requires a magic decoder ring to make sense of it all. For example "Meteor gathers all your JavaScript files, excluding anything under the client and public subdirectories,..." which suggested that I needed a public folder in order to render a more traditional page.
  • hapi has plenty of words but only covers a fraction of their server. When you install the module you'll see buckets of modules installed and just not enough to read.
One thing I did not like about meteor is that it did not use NPM.  Not that NPM is without warts but at least it's consistent.

hapi not so joy joy

The hapi framework is pretty awesome. My only complaint is that I have no idea what their state of readiness is. At least expressjs feels ready.

My new hammer is graohite

I am really starting to like graphite. It is able to collect data effortlessly. I'm still trying to figure out the best naming convention for the datasources but still effortless.

Friday, April 12, 2013

Bootstrap Metro theme

Someone published a metro theme for bootstrap. At first I thought it would be a novel idea.  Then I recalled that the talking heads were down on PC sales and blaming Microsoft's Windows 8.  So why on ear would someone continue to emulate Windows 8? The worst part is that the theme is basically static where one might be expecting more animated widgets.

So long redditt

In advance of google reader deprecation I just deleted my last redditt RSS feed and I can already breath easier.

Thursday, April 11, 2013

Big data says what?

Given the number of big data scale databases you'd think there was an endless supply of big data.

Just how many businesses really need these databases? In my estimation not many at all. So don't let them dominate the conversation for the wrong reasons.

Wednesday, April 10, 2013

Do you know RealTime?

That anyone would suggest that an HTTP-proxy or webserver of any kind is "realtime" means two very powerful things. (a) that person has absolutely no idea what RealTime means. (b) that person has less of an idea what a webserver is.

Monday, April 8, 2013

Lua or JavaScript?

The picture is getting clearer. There is so much junk out there in JavaScript land. Just look at the number and quality of dedicated logging modules.

OpenBSD - a wonderful sandbox

"Nothing extra; just the things you need to concentrate on the task at hand and not the junk that gets in the way or is distracting."

It couldn't be said any better.

A new thought on Continuous Delivery

If you find yourself checking the iPhone appstore for updates more than once a week then you are a candidate for CD as I am. What I want to know is how many iPhone users manually check for updates and at what rate?

Sunday, April 7, 2013

Informational alerts are an oxymoron.

Alerts need to be actionable not strictly informational. If the emergency broadcast system did a test once a day or sent anything other than a test once in a while then we might all be doomed.

Zero is not always zero in go.

A time.Time instance is never zero.

How would choose between lua and JavaScript?

I dunno.

The best time for perl dev

Was when core perl dev stalled; real perl systems work needs a rock solid and consistent base of tools. But it's also nice that there is a Rennaisance too.

Saturday, April 6, 2013

Still no time for Turing incomplete domain specific languages

I don't really know what it means to be Turing complete but it seems like a quality attribute for a DSL to have.

We need a framework that allows typical services to be decoupled from the application layer so that the DSL is functioning at the complexity of problem space.

Thank you Dave Thomas.

Nodejs community tweets might be cheats

Nodejs community tweets appear to randomly or regularly contain multiple bitly links to the same article within the same tweet and tweets are repeated and syndicated across nodejs advocates. Feels like gaming the system to me.

Friday, April 5, 2013

GOLANG Encoding not always ideal


When using GOLANG's encoding for JSON and the datatype is Time. "omitempty" does not work. It always emits the default value '0001-01-01 00:00:00 +0000 UTC'. This is not working as expected.


type Stuff struct {
  Cloned       time.Time   `json:"cloned,omitempty"`
  Expiration   time.Time   `json:"expiration,omitempty"`
}

Scaling Deployment

Every time I start a new project there is this realization that there are so many moving parts that really need to be addressed and are never part of the original development plan and yet there needs to be a bootstrap for that too. For example there are many type of logging that take place in development and production. I also hate building the infrastructure each time. What I'd prefer is a wrapper that would send my logs to loggly until I was ready to assume that role.

Thursday, April 4, 2013

Monolithic deployment file ... a la jar file

The monolithic code repository still has some value. It does get a little tricky when you implement continuous deployment but that another story. The jar file is nothing more than a compressed tar-like file with a little compression sugar sprinkled in.The only difference is that jar files are read by the java runtime engine so while other types of file objects make sense in system delivery it all amount to the same thing.

Tuesday, April 2, 2013

Agile, Kanban, scrum - MEH!

The processes are MEH but the vocabulary is spot on!

My New Server Naming Convention

I've decided to name my machines with the abbreviations of the Zodiac, Planets, and periodic table of elements. That gives me a working set of over 10K machine names. I might even add a single letter suffix in order to describe it's function(s).

My new all-in-one server might be designated:

TAU-E-O-LLPS

  • TAU - taurus
  • E - Earth
  • O - Oxygen
  • LLPS - Linux, Lighttpd, Postgres, sshd
For this to work you need a really good DNS support system and a very flexible application configuration system.

The Killer App

The killer app is not really the killer app but the killer framework. The idea came to me when I was watching the keynote from RubyConf AU 2013. Dave Thomas, the speaker, talked about many subjects, however, most notably he talked about developer productivity as it results from the granularity of the language; in his case Ruby and it's DSL-ness.

I do not particularly care for custom DSLs, however, general purpose embedded DSLs serve a terrific purpose.

Scale or the ability comes in many different flavors and many combo flavors too; and it can effect each point in the stack. It's also why companies move certain aspects of their applications to the client and sometimes back. There is also a migration to and from distributed computing and the monolithic appliance. However, in most cases the workflow or transaction and the infrastructure are linked together.

Being linked together refers to a number of linkages:

  • The source code is literally compiled and linked together
  • There is some logical aspect to a transaction that is known to all layers in the stack
  • The layers of the application stack are glued together
This simply cannot scale. Whether it's resources to implement new features, maintenance, or the increase the number of clients and server instances to support them. This will fail all attempts to scale and system availability.
One particular challenge is the server farm. What do you do when you have 100 or 1000 servers with a particular app or service. Do you take everything off the air for maintenance or can you do rolling migrations. What about point in time restores or recovery? What happens when you rolled out that latest patch... it runs for 24hours on the production canary... and is rolled out... only to find a serious bug that needs to be completely rolled back.(I hate hot plugging)
I'm not promoting one particular solution but an idea. The application framework is the application framework. It knows absolutely nothing about the actual transaction. Just that there is a transaction. It also knows how to move packages and route messages; not that it understands the contents of the message. And it knows how to deliver the response. And let it know how to execute some generic workflow.

In an over simplification the application framework can be a desktop app or a desktop app simulation of the web app framework. The web app framework could bloat with features for different classes of businesses but the workflow would stay the same.

As a side note. Many developers start to panic when they see architecture like this. They tend to believe that there is a certain amount of relegation or non-technical-ness that happens. Well this is part of the process. It's also why I think the DSL needs to be a proper language rather than the base implementation. And the most important thing is that there are so many things a business needs to run successfully that the core app is but only one piece. The other infrastructure elements are so much more important. That's for another post.

Monday, April 1, 2013

Dart for real dev.

The cool nerds are moving to dart. But is it a real migration? I saw the benchmark where darts version of the JavaScript form of the app out performed native java. I suppose it's the JIT effect.

It still requires too much plumbing to get real work done and it feels a lot like GWT which did not get adopted as quickly as needed.

This environment is still to volatile.

3 levels of logging goodness

Typical syslog and related logging systems implement a level system that address individual message context. However, logging usually has multiple contexts. (a)The framework, (b)the internal diagnostics [the application ping], (c) the application's transactions.

As sort of a best practice; if you're using syslog etc... then open multiple connections/categories. One per application context. And when you're "transactions" make certain to use a UUID or transaction id with EVERY single message so that you can aggregate the messages.

another bad day for open source

One of the hallmarks of a good open source project is just how complicated it is to install, configure and maintain. Happily gitlab and the ...