Friday, October 28, 2016

Managing configurations with object graphs

***
This post is basically a pitch I send to folks whom I think will be interested in a modern approach to configuration management. I am posting it here so I can refer people to it without sending them a long email.
***

One of the features of the HiveMind platform is a smart object technology that solves the problem of dealing with hierarchical configuration information often represented in formats Like YAML,JSON, Java Properties,XML...etc

The smart object technology allows developers/users to directly construct object graphs of any complexity. Once you have the actual object graph you can reverse the process back to representation in any one of the formats mentioned above.
 

I have setup a demo instance for trying it out @ http://demo.crudzilla.com:7000

Login with login info I sent you.

Be nice, you have full system access :)

To see an example representing the AWS IP list (https://ip-ranges.amazonaws.com/ip-ranges.json):

Navigate to: /com/crudzilla/betaApp/web/aws/index.ins

This is what a smart object looks like, the cool thing is that you can combine smart objects to compose any complex object graph and you use the file system to organize the smart objects.
Once you have your object graph you can serialize it to any suitable format as the included examples show:


http://demo.crudzilla.com:7000/betaApp/crud-appserver/aws/yaml/
http://demo.crudzilla.com:7000/betaApp/crud-appserver/aws/json/
http://demo.crudzilla.com:7000/betaApp/crud-appserver/aws/properties/
http://demo.crudzilla.com:7000/betaApp/crud-appserver/aws/xml/


This approach is quite powerful, beyond its use for configuration, it can be used to allow non-technical users to handle certain data management tasks where a developer need not be involved. For instance a developer working on an e-commerce site can offload product catalog management to business users who will use this feature to manage the catalog, while the developer focus on the application.

Tuesday, October 4, 2016

Hype on HackNews and Silicon Valley

One of the consequences of refusing to drink the in vogue kool-aid is that you remain sober and take in the full brunt of the silliness going on around you.

The technology industry overflows with such silliness, like any credible geek I spend too much time reading HackerNews even when I don't want to.

One odd phenomenon I have observed over the past few years is the fact that there is a rather peculiar writing style in Silicon Valley, seemingly meant to make writing more efficient in conveying hype.

Specifically, the desire to create emphasis when otherwise the point being made is prosaic has lead people in Silicon Valley to come up with this odd writing style where adverbs are deployed in ways that no decent writer would. Let's just say a good chunk of "influencers" in SV suffer from Hype-Nitis.

I have gleefully collected a small sample of these gems on HackerNews over the past couple of years:

atrociously bad
crucially important
astonishingly successful
growingly wants to be secular
closely involved and crucially helpful
severely unique and an incredible thing to witness
Something is dramatically wrong with her
It is an exceptionally great salary
early decline are vastly significant 
made an amazingly interesting point
It was a hugely important quarter
You just won't believe how vastly, hugely, mind-bogglingly big it is.
team massively grew
the hugely important and popular site
startup to a significantly larger organization
hugely newsworthy figure
This is insanely sad. This brilliant woman had so much left to share with us.
The OP is impressively throrough 
informatively good

Friday, September 30, 2016

Your code is not a project

Language matters, just as saying the wrong word to the wrong person can leave you with one less front tooth, so too can the incorrect use of language in general create a cascade of confusion that pervades an entire industry.

One of my pet peeves about the use of language in the software arena is the use of the word "Project". This usage as far as I know goes back to IDEs grouping software artifacts as projects. The notion of a project as the top level organizing construct for software projects (see what I did there?) is now a de facto standard. One problem with this is that it is a complete misuse of the notion of a project. A project is not a thing, it is a process! A project has (or at least should have) a well defined start and end.

As a process, by its very nature, its essence is vague. So when something whose essence is precise (software) is called a project it leaves the reader wondering exactly what is being described. Whenever I come across a documentation describing a piece of technology and then goes on to describe some top-level construct of its configuration as a "Project", I am left wondering exactly what this entails. In other words giving the top level construct its proper name would allow a reader to know immediately what is being described, calling it a project means I need to unwrap its meaning somewhere else.

For instance in designing Hivemind I deliberately stayed away from creating any top level construct that could be considered a "Project". Instead there is an application (a thing), then there is a Task/Project management feature which can be used to actually manage a project. In this way the application is just a component of some project (it could belong to more than one project), the application (or applications) are mere artifacts of the project, they are not the project itself. Now you may well need to organize a group of artifacts into some higher order category or construct, but this still won't be a project :)

The words you use for things (especially complicated things like software) often becomes an anchor for how you think about those things, so while it may seem harmless to mislabel things, there can be real negative impact over time. At the very least the rampant misuse of the term project within software leads to what I call "low grade" confusion.

#TGIF

Friday, September 23, 2016

Get out of the box sometimes

Little boxes on the Laptop,
Little boxes made of Javascript stacks,
Little boxes on the Laptop,
Little boxes all the same.
There's a green one and a pink one
And a blue one and a yellow one,
And they're all made out of Javascript stacks
And they all look just the same.

And the developers in the industry
All went to the IDEs,
Where they were put in boxes
And they came out all the same,
And there's devOps and Rubyers,
And micro services,
And they're all made out of Javascript stacks
And they all look just the same.

And they all play on the GitHub
And drink their Kool-aids dry,
And they all have pretty syntax
And the syntax go to HackNews,
And the syntax get approval stamp
And then to the IDEs,
Where they are put in boxes
And they come out all the same.

And the bros go into business
And marry and raise a VC round
In boxes made of Javascript stacks
And they all look just the same.
There's a green one and a pink one
And a blue one and a yellow one,
And they're all made out of Javascript stacks
And they all look just the same.

Happy Friday everyone!

Tuesday, August 30, 2016

JSON Information Management and Publishing for Technical and Business users

Like it or not JSON is the data format of the web at the moment. It has found uses in application configuration, taxonomy management and pretty much any domain that used to be handled by XML is now increasingly being taken over by JSON.

While our Hivemind product is first and foremost a web application delivery platform, it doubles as a full-blown Structured Information Manager and Publisher for JSON information. Both technical and non-technical users can use it to create and publish complex structured information without writing code.


Hivemind has a sophisticated Smart Object technology that can be used to create complex objects that are then serialized as JSON.

About Smart Objects

  • Smart Objects are an executable construct on the Hivemind platform, in executable form the file format is itself JSON. You can see an example of a Smart Object executable here: http://crudzilla.s3.amazonaws.com/ip-range.json
  • Smart Objects can invoke other Smart Objects in the way that any executable construct (eg. a php file) should be able to invoke another executable.
  • Smart objects can be invoked in code (eg. Groovy,Javascript,Closure,Ruby) and the resulting complex object is a composite made up of java Objects and ArrayLists.You can use them in your code just like any other object.
  • Smart Objects can be secured in a number of ways
    •   Fields can be marked as final to prevent browser supplied overrides
    •   They can be restricted to only be invoked by another smart object, in other words not invokable directly from the browser.
    •   You can apply role based security as in any Java application, you actually define roles using a smart object :)
  • Smart Objects are composed using the file system structure, in other words you can organize a filesystem folder structure that mirrors your structured information. This is very intuitive and makes it easy to think about your JSON information.

Smart Objects in action

Below is an example of a Smart Object setup for the AWS ip list (https://ip-ranges.amazonaws.com/ip-ranges.json). You can imagine that IP list could be maintained by anyone, they don't need to even know what JSON is.


1)A simple Smart Object representing an AWS IP


 2) Smart Object prefixes property invokes another Smart Object, thus leading to composition.


3)Secure a Smart Object

4) Test result from executing the Smart Object, it results in JSON.










Benefits

Developers can offload management of JSON information to business users: Often times developers rely on information that is managed by business users, or at least that should be managed by business or non-technical users. For instance a developer building an e-commerce site would need to get information from a product catalog. A developer may need some taxonomy managed by someone else who's non-technical. In order for developers to work together with non-technical users requires the non-technical user mocking about with complex JSON or XML files, increasing the risk of breaking applications when they make simple syntax mistakes.

Whether it is in the domain of retail, healthcare, manufacturing or technology, structure information is everywhere. Hivemind's Smart object technology can help you tame your JSON information.



Friday, August 26, 2016

Hivemind 2.0 is out!

We're happy to announce the release of Hivemind 2.0. This release is a major UI upgrade with a design that conveys the modern approach to web application development that Hivemind is built for. As always your feedback is appreciated.





Wednesday, August 3, 2016

Something pretty, this way comes

It's been two years since there's been a significant development of Hivemind, that is coming to an end. We are going to ratchet up development of the platform and ramp up business activity to get customer acquisition in high gear. To that end we are working on a major UI overhaul of the Hivemind platform.


Hivemind is a very modern platform, the current UI is a bit dated. We are feverishly working on a modern UI upgrade to match the innovation of the platform. Below is a sneak preview of the new slick UI!: