Preview: Sean McGrath
Sean McGrath's Weblog.
Last Build Date: Thu, 22 Sep 2016 12:45:38 +0000
The next big exponential step in AI
Wed, 21 Sep 2016 13:11:00 +0000
Assuming, for the moment, that the current machine learning bootstrap
pans out, the next big multiplier is already on the horizon.
As more computing is expressed in forms that require super-fast, super-scalable linear algebra algorithms (a *lot* of machine learning techniques do this), it becomes very appealing to find ways to execute them on quantum computers. Reason being, exponential increases are possible in terms of parallel execution of certain operations.
There is a fine tradition in computing of scientists getting ahead of what today's technology can actually do. Charles Babbage, Dame Ada Lovlace, Alan Turing, Doug Englebart, Vannever Bush, all worked out computing stuff that was way ahead of the reality curve, and then reality caught up with their work.
If/when quantum computing gets out of the labs, the algorithms will already be sitting in the Machine Learning libraries ready to take advantage of them, because forward looking researchers are working them out, now.
In other words, it won't be a case of "Ah, cool! We have access to a quantum computer! Lets spend a few years working out how best to use them.". Instead it will be "Ah, cool!. We have access to a quantum computer! Lets deploy all the stuff we have already worked out and implemented, in anticipation of this day."
It reminds me of the old adage (attributable to Poyla, I think) about "Solving for N". If I write an algorithm that can leverage N compute nodes, then it does not matter that I might only be able to deploy it with N = 1 because of current limitations. As soon as new compute nodes become available, I can immediately set N = 2 or 2000 or 20000000000 and run stuff.
With the abstractions being crafted around ML libraries today, the "N" is being prepped for some very large potential values of N.
Deep learning, Doug Englebart and Jimmy Hendrix
Thu, 15 Sep 2016 10:49:00 +0000
The late great Doug Englebart did foundational work in many areas of computing and was particularly interested in the relationship between human intelligence and machine intelligence.
Even a not-so-smart machine can augment human productivity if even simple cognitive tasks can be handled by the machine. Reason being, machines are super fast. Super fast can compensate for "not-so-smart" in many useful domains. Simple totting up of figures, printing lots of copies of a report, shunt lots of data around, whatever.
How do you move a machine from "not-so-smart" to "smarter" for any given problem? The obvious way is to get the humans to do the hard thinking and come up with a smarter way. It is hard work because the humans have to be able to oscillate between smart thinking and thinking like not-so-smart machines because ultimately the smarts have to be fed to the not-so-smart machine in grindingly meticulous instructions written in computer-friendly (read "not-so-smart") programs. Simple language because machines can only grok simple language.
The not-so-obvious approach is to create a feedback loop where the machine can change its behavior over time by feeding outputs back into inputs. How to do that? Well, you got to start somewhere so get the human engineers to create feedback loops and teach them to the computer. You need to do that to get the thing going - to bootstrap
then stand back....
Things escalate pretty fast when you create feedback loops! If the result you get is a good one, it is likely to be *a lot* better than your previous best because feedback loops are exponential.
Englebart's insight was to recognize that the intelligent, purposeful creation of feedback loops can be a massive multiplier : both for human intellect at the species level, and at the level of machines. When it works, it can move the state of the art of any problem domain forward, not by a little bit, but by *a lot*.
A human example would be the invention of writing. All of a sudden knowledge could survive through generations and could spread exponentially better than it could by oral transmission.
The hope and expectation around Deep Learning is that it is basically a Doug Englebart Bootstrap for machine intelligence. A smart new feedback loop in which the machines can now do a vital machine intelligence step ("feature identification") that previously required humans. This can/should/will move things forward *a lot* relative to the last big brohuha around machine intelligence in the Eighties.
The debates about whether or not this is really "intelligence" or just "a smarter form of dumb" will rage on in parallel, perhaps forever.
Relevance to Jimmy Hendrix? See https://www.youtube.com/watch?v=JMyoT3kQMTg
The scourge of easily accessible abstraction
Thu, 11 Aug 2016 11:57:00 +0000
In software, we are swimming in abstractions. We also have amazingly abstract tools that greatly enhance our ability to create even more abstractions.
"William of Ockham admonished philosophers to avoid multiplying entities, but computers multiple them faster than his razor can shave." -- John F. Sowa, Knowledge Representation.
Remember that the next time you are de-referencing a URL to get the address of a pointer to a factory that instantiates an instance of meta-class for monad constructors...
Sebastian Rahtz, RIP
Wed, 03 Aug 2016 10:57:00 +0000
It has just now come to my attention that Sebastian Rahtz passed away earler this year.
RIP. Fond memories of conversations on the xml-dev mailing list.
Software self analysis again
Wed, 20 Jul 2016 14:11:00 +0000
Perhaps a better example for the consciousness post
would have been to allow the application on the operating system to have access to the source code for the hypervisor two levels down. That way, the app could decide to change the virtualization of CPUs or the contention algorithms on the virtualized network interfaces and bootstrap itself a new hypervisor to host its own OS.
The question naturally arises, what scope has an app - or an OS - got for detecting that it is on a hypervisor rather than real hardware? If the emulation is indistinguishable, you cannot tell - by definition. At which point the emulated thing and the thing emulated have become indistinguishable. At which point you have artificially re-created that thing.
This is all well worn territory in the strong Vs weak AI conversations of course.
My favorite way of thinking about it is this:
1 - we don't understand consciousness and thus we cannot be sure we won't re-create it by happenstance, as we muck about with making computers act more intelligently.
2 - If we do create it, we likely won't know how we did it (especially since it is likely to be a gradual, multi-step thing rather than a big-bang thing)
3 - because we won't know what we did to create it, we won't know how to undo it or switch it off
4 - if it improves by iteration and it iterates a lot faster in silicon than we do in carbon, we could find ourselves a distant second in the earth-based intelligence ranking table rather quickly :-)
Best if we run all the electrical generation on the planet with analog methods and vacuum tubes so that we can at least starve it of electricity if push comes to shove:-)
English as an API
Sat, 16 Jul 2016 16:55:00 +0000
Like the last post, this I am filing under "speculative"
Chat bots strip away visual UI elements in favor of natural language in a good old fashioned text box.
Seems kind of retro but, perhaps something deeper is afoot. For the longest time, we have used the phrase "getting applications to talk to each other" as a sort of business-level way of saying, "get applications to understand each others APIs and/or data structures."
Perhaps, natural language - or a controlled version of natural language - will soon become a viable way of getting applications to talk to each other. I.e. chatbots chatting with other chatbots, by sending/receiving English.
One of the big practical upshots of that - if it transpires - is that non-programmers will have a new technique for wiring up disparate applications. I.e. talk to each of them via their chat interface, then gradually get them talking to each other...
The surprising role of cloud computing in the understanding of consciousness
Sat, 16 Jul 2016 16:00:00 +0000
I am filing this one under "extremely speculative".
I think it was Douglas Hofstadter's book "I am a strange loop" that first got me thinking about the the possible roles of recursion and self-reference in understanding consciousness.
Today - for no good reason - it occurred to me that if the Radical Plasticity Theory
is correct, to emulate/re-create consciousness we need to create the conditions for consciousness to arise. Doing that requires arranging a computing system that can observe every aspect of itself in operation.
For most of the history of computing, we have had a layer of stuff that the software could only be dimly aware of, called the hardware.
With virtualization and cloud computing, more and more of that hardware layer is becoming, itself, software and thus, in principle, open to fine grained examination by the software running on....the software, if you see what I mean.
To take an extreme example, a unix application could today be written that introspects itself, concludes that the kernel scheduler logic should be changed, writes out the modified source code for the new kernel, re-compiles it, boots a Unix OS image based on it, and transplant itself into a process on this new kernel.
 Emulation versus re-creation of consciousness. Not going there.
The subtle complexities of legal/contractual ambiguity
Mon, 20 Jun 2016 13:51:00 +0000
The law is not a set of simple rules and the rule of law is not - and arguably cannot -be reduced to a Turing Machine evaluating some formal expression of said rules.
A theme of mine
for some time has been how dangerous it is to junp to conclusions about the extent to which the process of law - and its expression in the laws themselves - can be looked upon purely in terms of a deductive logic system in disguise.
Laws, contracts etc. often contain ambiguities that are there on purpose. Some are tactical. Some are there in recognition of the reality that concepts like "fairness" and "reasonable efforts" are both useful and unquantifiable.
In short there are tactical, social and deep jurisprudence-related reasons for the presence ambiguity in laws/contracts.
Trying to remove them can lead to unpleasant results.
Case in point : the draining of millions of dollars from the DAO. See writeup on Bloomberg : Ethereum Smart Contracts
25 years if the Internet in Ireland - a personal recollection of the early days
Fri, 17 Jun 2016 13:25:00 +0000
So today is the Internets 25th anniversary in Ireland.
In 1991 I was working with a financial trading company, developing technical analysis software for financial futures traders in 8086 assembly language and C using PCs equipped with TMS34010
I cannot remember how exactly...possible through the Unix Users Group I ended up getting a 4800 KBS modem connection to a Usenet feed from Trinity via the SLIP protocol
Every day I would dial up
and download comp.text.sgml from Usenet onto my Sun Roadrunner
Not long thereafter, Ireland Online happened and I was then dialling up Furbo in the Gaeltacht of Connemara because it was the first access point to the WWW in Ireland.
I ditched my compuserv e-mail account not long after and became firstname.lastname@example.org on comp.text.sgml
So much has changed since those early days...and yet so much as stayed the same.
From textual authority to interpretive authority: the next big shift in legal and regulatory informatics
Fri, 20 May 2016 09:55:00 +0000
This paper : law and algorithms in the public domain from a journal on applied ethics is representative, I think, of the thought processes going on around the world at present regarding machine intelligence and what it means for law/regulation.
It seems to me that there has been a significant uptick in people from diverse science/philosophy backgrounds taking an interest in the world of law. These folks range from epistemologists to bioinformaticians to statisticians to network engineers. Many of them are looking at law/regulation through the eyes of digital computing and asking, basically, "Is law/regulation computation?" and also "If it is not currently computation, can it be? Will it be? Should it be?"
These are great, great questions. We have a long way to go yet in answering them. Much of the world of law and the world of IT is separated by a big chasm of mutual mis-understanding at present. Many law folk - with some notable exceptions - do not have a deep grasp of computing and many computing folk - with some notable exceptions - do not have a deep grasp of law.
Computers are everywhere in the world of law, but to date, they have primarily been wielded as document management/search&retrieval tools. In this domain, they have been phenomenally successful. To the point where significant textual authority has now transferred to digital modalities from paper.
Those books of caselaw and statute and so on, on the shelves, in the offices. They rarely move from the shelves. For much practical, day-to-day activity, the digital instantiations of these legislative artifiacts are normative and considered authoritative by practitioners. How often these days to legal researchers go back to the paper-normative books? Is it even possible anymore in a world where more and more paper publication is being replaced by cradle-to-grave digital media? If the practitioners and the regulators and the courts are all circling around a set of digital artifacts, does it matter any more if the digital artifact is identical to the paper one?
Authority is a funny thing. It is mostly a social construct. I wrote about this some years ago here: Would the real, authentic copy of the document please stand up? If the majority involved in the world of law/regulation use digital information resource X even though strictly speaking X is a "best efforts facsimile" of paper information resource Y, then X has de-facto authority even though it is not de-jure authoritative. (The fact that de-jure texts are often replaced by de facto texts in the world of jure - law! - is a self-reference that will likely appeal to anyone who has read The Paradox of Self Amendment by Peter Suber.
We are very close to being at the point with digital resources in law/regulation have authority for expression but it is a different kettle of fish completely to have expression authority compared to interpretive authority.
It is in this chasm between authority of expression and authority of interpretation that most of the mutual misunderstandings between law and computing will sit in the years ahead I think. On one hand, law folk will be too quick to dismiss what the machines can do in the interpretive space and IT people will be too quick to think the machines can quickly take over the interpretive space.
The truth - as ever - is somewhere in between. Nobody knows yet where the dividing line is but the IT people are sure to move the line from where it currently is (in legal "expression" space) to a new location (in legal "interpretation" space).
The IT people will be asking the hard questions of the world of law going forward. Is this just computing in different clothing? If so, then lets make it a computing domain. If it is not one today, then can we make it one tomorrow? If it cannot be turned into a computing d[...]
From BSOD to UOD
Mon, 16 May 2016 14:08:00 +0000
I don't get many "Blue Screen of Death" type events these days : In any of the Ubuntu, Android, iOS, Window environments I interact with. Certainly not like the good old days when rebooting every couple of hours felt normal. (I used to keep my foot touching the side of my deskside machine. The vibrations of the hard disk used to be a good indicator of life back in the good old days. Betcha that health monitor wasn't considered in the move to SSDs. Nothing even to listen too these days, never mind touch.)
I do get Updates of Death though - and these are nasty critters!
For example, your machine auto-updates and disables the network connection leaving you unable to get at the fix you just found online....
Mon, 09 May 2016 16:13:00 +0000
is a thing. Wow.
As a thing, it is part of a bigger thing.
That bigger thing seems to be this: given enough cheap compute power, the time taken to perform zillions of iterations can be made largely irrelevant.
Start stupid. Just aim to be fractionally less stupid the next time round, and iterations will do the rest.
The weirdest thing about all of this for me is that if/when iterated algorithmic things start showing smarts, we will know the causal factors that lead to the increased smartness, but not the rationale for any individual incidence of smart-ness.
As a thing, that is part of a bigger thing.
That bigger thing is that these useful-but-unprovable things will be put to use in areas where humankind as previously expected the presence of explanation
. You know, rules, reasoning, all that stuff.
As a thing, that is part of a bigger thing.
That bigger thing is that in many areas of human endeavor it is either impossible to get explanations - (i.e. experts who know what to do, but cannot explain why in terms of rules.), or the explanations need to be taken with a pinch of post-hoc-ergo-propter-hoc salt, or a pinch or retroactive goal-setting salt.
As a thing, that is part of a bigger thing.
When the machines come, and start doing clever things but cannot explain why....
...they will be just like us.
Statistics and AI
Thu, 05 May 2016 09:44:00 +0000
We live at a time where there is more interest in AI than ever and it is growing every day.
One of the first things that happens when a genre of computing starts to build up steam is that pre-existing concepts get subsumed into the new genre. Sometimes, the adopted concepts are presented in a way that would suggest they are new concepts, created as part of the new genre. Sometimes they are. But sometimes they are not.
For example, I recently read some material that presented linear regression as a machine learning technique.
Now of course, regression has all sorts of important contributions to make to machine learning but it was invented/discovered long long before the machines came along.
Cutting the inconvenient protrusions from the jigsaw pieces
Thu, 14 Apr 2016 12:34:00 +0000
There is a school of thought that goes like this....
(1) To manage data means to put it in a database
(2) A 'database' means a relational database. No other database approach is really any good.
(3) If the data does not fit into the relational data model, well just compromise the data so that it does. Why? See item (1).
I have no difficulty whatsover with recommending relational databases where there is a good fit between the data, the problem to be solved, and the relational database paradigm.
Where the fit isn't good, I recommend something else. Maybe index flat files, or versioned spreadsheets, documents, a temporal data store....whatever feels least like I am cutting important protrusions off the data and off the problem to be solved.
However, whenever I do that, I am sure to have to answer the "Why not just store it in [Insert RDB name]?" question.
It is an incredibly strong meme in modern computing.
Algorithms where human understanding is optional - or maybe even impossible
Mon, 14 Mar 2016 10:52:00 +0000
I think I am guilty of holding on to an AI non-sequitur for a long time. Namely the idea that AI is fundamentally limited by our ability as humans to code the rules for the computer to execute. If we humans cannot write down the rules for X, we cannot get the computer to do X.
Modern AI seems to have significantly lurched over to the "no rules" side of the field where phrases like CBR (case based reasoning) and Neural Net Training Sets abound...
But with an interesting twist that I have only recently become aware of. Namely, using bootstrapping to use generation X of an AI system to produce generation X+1.
The technical write-ups about the recent stunning AlphaGo
victory make reference to the boostrapping of AlphaGo. As well as learning from the database of prior human games, it has learned by playing against itself....
Doug Englebart springs to mind and his bootstrapping strategy
Douglass Hofstadter springs to mind and his strange loops model of consciousness
Stephen Wolfram springs to mind and his feedback loops of simple algorithms
for rapidly generating complexity.
AI's learning by using the behavior of the previous generation AI as "input" in the form of a training set sounds very like iterating a simple Wolfram algorithm or a fractal generating function, except that the output of each "run", is the algorithm for the next run.
The weird, weird, weird thing about all of this, is that we humans don't have to understand the AIs we are creating. We are just creating the environment in which they can create themselves.
In fact, it may even be the case that we cannot understand them because, by design, there are no rules in there to be dug out and understood. Just an unfathomably large state space of behaviors.
I need to go to a Chinese room
, and think this through...
Thu, 10 Mar 2016 16:44:00 +0000
feels like a big deal to me. In general, hardware-lead innovations tend to jumpstart software design into interesting places, moreso than software-lead innovations drag hardware design into interesting places.
With software driving hardware innovation, the results tend to be of the bigger, faster, cheaper variety. All good things but not this-changes-everything type moments.
With hardware driving software innovation however, software game changers seem to come along sometimes.
Telephone exchanges -> Erlang -> Elixer.
Packet switching -> TCP/IP -> Sockets
BGP Routers -> Multihoming
VR Headsets -> Immersive 3D worlds
I have noticed that things tend to come full circle though. Sooner or later, the any hardware bits that can themselves be replaced by software bits, are replaced:-)
This loopback trend is kicking into a higher gear at the moment because of 3D printing. I.e. a hardware device is conceived of. In order to build the device, the device is simulated in software to drive the 3D printer. Any such devices that *could* remain purely software, do so eventually.
A good example is audio recording. A modern DAW like ProTools or Reaper now provides pure digital emulators for pretty much any piece of audio hardware kit you can think of: EQs, pre-amps, compressors, reverbs etc.
XML and St Patrick
Fri, 04 Mar 2016 10:27:00 +0000
I am finding it a bit hard to believe that I wrote this *fourteen* years ago.
Patrick to be Named Patron Saint of Software Developers
a dramatic development, scholars working in Newgrange, Ireland, have
deciphered an Ogham stone thought to have been carved by St. Patrick
himself. The text on the stone predicts, with incredible accuracy, the
trials-and-tribulations of IT professionals in the early 21st century.
Calls are mounting for St. Patrick to be named the patron saint of
The full transcription of the Ogham stone is presented here for the first time:DeXiderata
Go placidly amid the noise and haste and remember what peace there may be in silence.
As far as possible, without surrender, accommodate the bizarre tag names and strange attribute naming conventions of others.
your truth quietly and clearly, making liberal use of UML diagrams.
Listen to others, even the dull and ignorant, they too have their story
and won't shut up until you have heard it.
Avoid loud style
sheets and aggressive time scales, they are vexations to the spirit. If
you compare your schemas with others, you will become vain and bitter
for there will always be schemas greater and lesser than yours -- even
if yours are auto-generated.
Enjoy the systems you ship as well
as your plans for new ones. Keep interested in your own career, however
humble. It's a real possession in the changing fortunes of time and
Cobol may yet make a comeback.
Exercise caution in your use of
namespaces for the world is full of namespace semantic trickery. Let
this not blind you to what virtue there is in namespace-free markup.
Many applications live quite happily without them.
Especially do not feign a working knowledge of RDF where no such
knowledge exists. Neither be cynical about Relax NG; for in the face of
all aridity and disenchantment in the world of markup, James Clark is as
perennial as the grass.
Take kindly the counsel of the years,
gracefully surrendering the things of youth such as control over the
authoring subsystems and any notion that you can dictate a directory
structure for use by others.
Nurture strength of spirit to
nourish you in sudden misfortune but do not distress yourself with dark
imaginings of wholesale code re-writes.
Many fears are born of fatigue and loneliness. If you cannot make that XML document parse, go get a pizza and come back to it.
a wholesome discipline, be gentle with yourself. Loosen your content
models to help your code on its way, your boss will probably never
You are a child of the universe no less than the trees
and all other acyclic graphs; you have a right to be here. And whether
or not it is clear to you, no doubt the universe is unfolding as it
Therefore be at peace with your code, however knotted it
may be. And whatever your labors and aspirations, in the noisy confusion
of life, keep peace with your shelf of manuals. With all its sham,
drudgery, and broken dreams, software development is a pretty cool thing
to do with your head. Be cheerful. Strive to be happy.
Software complexity accelerators
Fri, 26 Feb 2016 10:15:00 +0000
It seems to me that complexity in software development, although terribly hard to measure, has steadily risen from the days of Algol 68 and continues to rise.
In response to the rise, we have developed mechanisms for managing - not removing - managing the complexity.
These management - or perhaps I should say 'containment' mechanisms have an interesting negative externality. If a complexity level of X was hard to contain before, but thanks to paradigm Y is not contained, the immediate side-effect is an increase in the value of X:-)
It reminds me of an analysis I found somewhere about driving speed and seat belts. Apparently, steat belts can have the effect of increasing driving speed. Reason being, we all have a risk level we sub-consciously apply when driving. Putting on a seat belt can make us feel that a higher speed is now possible without increasing our risk level.
So what sort of "seat belts" have we added into software development recently? I think Google Search is a huge one. Rather than reduce the complexity of an application as evidenced by the amount of debugging/head-scratching you need to do, we have accelerated the process of finding fixes online.
Another one is open source. We can now leverage a world-wide hive-mind that collectively "wraps its head around" a code-base so that code-base can become more complex than it could if a finite team work the code-base.
Another one is cloud. Client/Server-style computing models push most of the complexity of management into the server side. Applications that would be incredibly complex to manage in todays diverse OS world if they were thick-clients are easier to manage server-side, thus creating headroom for new complexity which, sure enough gets added to the mix.
Is this phenomenon of complexity acceleration thanks to better and better complexity containment a bad thing?
I honestly don't know.
It's obvious really
Fri, 19 Feb 2016 10:22:00 +0000
Nothing is more deserving of questioning, than an obvious conclusion.
Fixity, Vellums and the curious case of the rotting bits
Thu, 11 Feb 2016 16:07:00 +0000
So, vellum may be on the way out in the UK Parliament
Many deep and thorny issues here.
Thought experiment: In your hand you have a 40 page document. On your computer screen you have an electronic document open in a word processor. You have been told they they are "the same document".
How can you tell? What does it even mean to say that they are the "same"? Does it matter if there is no sure-fire way to prove it?
Let us start at the end of that list of questions and work backwards. Does it matter that there is no sure-fire way to prove it? Most of the time, it does not matter if you cannot prove they are the same. Over the years since the computerization of documents, we have devised various techniques for managing the risks of differences arising between what the computer says and what the sheets of paper say. However, when it does matter it tends to matter a whole bunch. Examples are domains such as legal documents, mission critical procedure manuals, that sort of thing.A very common way of mitigating the risk of differences arising between paper and electronic texts is to declare the electronic version to be the real, authentic document and treat the paper as a "best efforts" copy or rendering of the authentic document. If the printing messes up and some text gets chopped off the right hand margin we think "No big deal". Annoying but not cataclysmic. The electronic copy is the real one and we can just go back to the source any time we want......Yes, as long as the electronic source is not, itself, an ambiguous idea. Again, we have developed practices to mitigate this risk. If I author a document in, say, FrameMaker but export RTF to send to you, the FrameMaker is considered the real, authentic electronic file. If anything happens to the RTF content - either as it is exported, transmitted or imported by you into some other application - we refer back to the original electronic file which is the FrameMaker incarnation.......If we still have it up to date. The problem is that we do not print FrameMaker or Word or Quark Express. We tend to print "frozen" renderings of these things. Things like postscript and PDF. On the way to paper, it is not uncommon for fixes to be required just prior to the creation of very expensive printing plates. If something small needs to be fixed, it will probably get fixed at 2 a.m. in the postscript or PDF file...which is now out of sync with the original FrameMaker file......Which, come to think of it, might not have been as clear cut an authoritative source as I made it out to be. It is not uncommon for applications like FrameMaker, Adobe CS2, Quark etc. to be used downstream of an authoring process that utilizes Microsoft Word or Corel Wordperfect or OpenOffice or some Webb-y browser plug-in.If (i.e. when) errors are found in document proofs the upstream documents should really be fixed and the DTP versions re-constituted. Otherwise, the source documents get out of sync with the paper copy very quickly indeed. Worse, the differences between the source documents and the paper copy may be in the form of small errors. A period missing here, a dollar sign there...Small enough to be very hard to spot with proofreading but large enough to be very serious in for example, legal documents.What to do? Well, we need to freeze-dry "cuts" of these documents to remove all ambiguity and then institute rigorous policies and procedures to ensure that changes are properly reflected everywhere along the document production toolchain......Which, these days, can be quite a complicated tool chain. F[...]
The biggest IT changes in the last 5 years: The re-emergence of data flow design
Fri, 05 Feb 2016 10:41:00 +0000
My first exposure to data flow as an IT design paradigm came around 1983/4 in the form of Myers and Constantine's work on "Structured Design" which dates from 1974.
I remember at the time finding the idea really appealing but yet, the forces at work in the industry and in academic research pulled mainstream IT design towards non-flow-centric paradigms. Examples include Stepwise Decomposition/Structured Programming
(e.g Dijkstra), Object Oriented Design
e.g. (Booch), Relational Data modelling
Over the years, I have seen pockets of mainstream IT design terms emerging that have data flow-like ideas in them. Some recent relevant terms would be Complex Event Processing
and stream processing
Many key dataflow ideas are built into Unix. Yet creating designs leveraging line-oriented data formats, piped through software components, local-and-remote, everything from good old 'cat' to GNU Parallels
and everything in between, has never, to my knowledge, been given a design name reflective of just how incredibly powerful and commonplace it is.
Things are changing I believe, thanks to cloud computing and multi-core parallel computing in general. Amazon AWS pipeline, Google Dataflow, Google Tensorflow are good examples. Also, bubbling away under the radar are things like FBP
(Flow Based Programming), buzz around Elixer
and similar such as shared-nothing architectures.
A single phrase is likely to emerge soon I think. Many "grey beards" from JSD (Jackson Stuctured Design), to IBM MQSeries (asynch messaging), to Ericsson's AXE-10
Erlang engineers, to Unix pipeline fans, will do some head-scratching of the "Hey, we were doing this 30 years ago!" variety.
So it goes.
Personally, I am very excited to see dataflow re-emerge to mainstream. I naturally lean towards thinking in terms of dataflow anyway. I can only benefit from all the cool new tools/techniques that come with mainstreaming of any IT concept.
The 'in', 'on' and 'with' questions of software development
Thu, 04 Feb 2016 11:40:00 +0000
I remember when the all important question for a software dev person looking at a software component/application was "What is it written in?"
Soon after that, a second question became very important "What does it run on?"
Nowadays, there is a third, really important question, "What is it build/deployed with?"
"In" - the programming language of the component/app itself
"On" - the run-time-integration points e.g. OS, RDB, Browser, Logging
"With" - the dev/ops tool chain eg. source code control, build, regression, deploy etc.
In general, we tend to underestimate the time, cost and complexity of all three :-) However, the "With" category is the toughest to manage as it is, by definition, scaffolding used as part of the creation process. Not part of the final creation.
Blockchain this, blockchain that...
Tue, 02 Feb 2016 12:18:00 +0000
It is fun watching all the digital chatter about blockchain at the moment. There is wild stuff at both ends of the spectrum. I.e. "It is rubbish. Will never fly. All hype. Nothing new here. Forget about it." on one end and "Sliced bread has finally met its match! Lets appoint a CBO (Chief Blockchain Officer)" on the other.
Here is the really important bit I think: The blockchain shines a light on an interesting part of the Noosphere. The place where trust in information is something than can be established without needing a central authority.
That's it. Everything about how consensus algorithms work, how long they take to run, how computationally expensive they are, are all secondary and the S curve will out (http://en.wikipedia.org/wiki/Innovation). I.e. that implementation stuff will get better and better.
Unless of course, the proves to be some hard limit imposed by information theory that cannot be innovated around e.g. something analogous to the CAP Theorem or Entropy Rate Theorem or some such.
To my knowledge, no such fundamental limits are on the table at this point. Thus the innovators are free to have a go and that is what they will do.
The nearest thing to a hard limit that I can see on the horizon is the extent to which the "rules" found in the world of contracts/legislation/regulation can be implemented in "rules" that machines can work with. This is not so much an issue for the trust concepts of Blockchain as it is for the follow-on concept of Smart Contracts.
The biggest IT changes in the last 5 years: The death-throes of backup-and-delete based designs
Tue, 26 Jan 2016 12:16:00 +0000
One of the major drivers in application design is infrastructure economics i.e. the costs - both in capex an opex terms - of things like RAM, non-volatile storage, compute power, bandwidth, fault tolerance etc.
These economic factors have changed utterly in the 35 years I have been involved in IT, but we still have a strong legacy of designs/architectures/patterns that are ill suited to the new economics of IT.
Many sacred cows of application design such as run-time efficiencies of compiled code versus interpreted code or the consistency guarantees of ACID transactions, can be traced back to the days when CPU cycles were costly. When RAM was measured in dollars per kilobyte and when storage was measured in dollars per megabyte.
My favorite example of a deeply held paradigm which I believe has little or no economic basis today is the concept of designs that only keep a certain amount of data in online form, dispatching the rest, at periodic intervals, to offline forms e.g. tape, disc that require "restore" operations to get them back into usable form.
I have no problem with the concept of backups:-) My problem is with the concept of designs that only keep, say, 1 years worth of data online. This made a lot of sense when storage was expensive because the opex costs of manual retrieval were smaller than the opex costs of keeping everything online.
I think of these designs as backup-and-delete designs. My earliest exposure to such a design was on an IBM PC with twin 5 and 1/4 inch floppy disk drives. An accounting application ran from Drive A. The accounting data file was in Drive B. At each period-end, the accounting system rolled forward ledger balances and then - after a backup floppy was created - deleted the individual transactions on Drive B. That was about 1984 or so.
As organizations identified value in their "old data" -for regulatory reporting or training or predictive analytics, designs appeared to extract the value from the "old" data. This lead to a flurry of activity around data warehousing, ETL (extract, transform, load), business intelligence dashboards etc.
My view is that these ETL-based designs are a transitionary period. Designers in their twenties working today, steeped as they are in the new economics of IT, are much more likely to create designs that eschew the concept of ever deleting anything. Why would you when online storage (local disk or remote disk, is so cheap?) and there is alway the possibility of latent residual value in the "old" data.
Rather than have one design for day-to-day business and another design for business intelligence, regulatory compliance, predictive analytics, why not have one design that addresses all of these? Apart from the feasibility and desirability of this brought about by the new economics of IT, there is another good business reason to do it this way. Simply put, it removes the need for delays in reporting cycles and predictive analytics. Ie. rather than pull all the operational data into a separate repository and crunch it once a quarter or once a month, you can be looking at reports and indicators that are in near-realtime.
I believe that the time is coming when the economic feasibility of near-realtime monitoring and reporting becomes a "must have" in regulated businesses because the regulators will take the view that well run businesses should have it. In the same way that a well run business today, is expected to have low [...]
The biggest IT changes in the last 5 years: Multi-gadget User Interfaces
Mon, 25 Jan 2016 15:36:00 +0000
In the early days of mobile computing, the dominant vision was to get your application suite on "any device, at any time". Single purpose devices such as SMS messengers, email-only messengers faded from popularity, largely replaced by mobile gadgets that could, at least in principle, do every thing that a good old fashioned desktop computer could do.
Operating system visions started to pop up everywhere aimed at enabling a single user experience across a suite of productivity applications, regardless of form-factor, weight etc.
Things (as ever!) have turned out a little differently. Particular form factors e.g. smart phone, tend to be used as the *primary* device for a subset of the users full application suite. Moreover, many users like to use multiple form-factors *at the same time*.
Some examples from my own experiences. I can do e-mail on my phone but I choose to do it on my desktop most of the time. I will do weird things like e-mail myself when on-the-road, using a basic e-mail sender, to essentially put myself in my own in-box. (Incidentally, my in-box is my main daily GTD
focus. I can make notes to myself on my desktop but I tend to accumulate notes on my smart phone. I keep my note-taker-app open on the phone even when I am at the desktop computer and often pick it up to make notes.
I can watch Youtube videos on my desktop but tend to queue up videos instead and then pick them off one-by-one from my smart-phone, trying to fit as many of them into "down time" as I can. Ditto with podcasts. I have a TV that has all sorts of "desktop PC" aspects from web browsers to social media clients but I don't use any of it. I prefer to use my smartphone (sometimes my tablet) while in couch-potato mode and will often multi-task my attention between the smartphone/tablet and the TV. I find it increasingly annoying to have to sit through advertizing breaks on TV and automatically flick to smartphone/tablet for ad breaks.
I suspect there is a growing trend towards a suite of modalities (smartphone, tablet, smart TV, smart car) and a suite of applications that in practical use, have smaller functionality overlaps than the "any device, at any time" vision of the early days would have predicted. A second, related trend is increasingly common use-cases where users are wielding multiple devices *at the same time* to achieve tasks.
Each of us in this digital world, is becoming a mini-cloud of computing power hooked together over a common WIFI hub or a bluetooth connection or a physical wire. As we move from home to car to train to office and back again, we reconfigure our own little mini-cloud to get things done. The trend towards smartphones becoming remote controls for all sorts of other digital gadgets is accelerating this.
I suspect that the inevitable result of all of this is that application developers will increasingly have to factor in the idea that the "user interface" may be a hybrid mosaic of gadgets, rather than any one gadget. With some gadgets being the primary for certain functionality.