% Mind the Tools % Alex Payne
The slides are available on slideshare.
- Twitter since 2007
- Working on the web since age 12 (1995) (a prerelease of Mosaic at his mother's office at UNiversity)
- Nuts abotu PLs (Co-author of Programming Scala from O'Reilly)
- Not definite counting units
- No specific colours
- Linguistic sturctures simplified and relative
- Has shaped culture, social strucutre, etc. (Little social hierarchy, etc.)
We don't tend to think of the tools we use -- they sink into the backgeound while we're in the "zone" -- but they affect the way we work and what we do.
_why (possibly "Jonathon"). Mentioned why's framework for teaching kids programming.
Some people say it's easy to learn to prog in the browser, but it takes three different language.
We're used to it and have become polyglots, but does it really have to be this way?
- A little history
- how have languages shaped the web
(Don't be offended if your "era" is listed as over.)
In the beginning
- HTML (1990-1). First "proper" soec in 1993. Mosaic 1.0 in April 1993
- as CERN announces the Web will be open and free.
- CGI standard emerges in 1993 allowing web applications G
- Using C and Perl for CGI scripts
- Key-value pairs for data structures
- A primorial soup of web applications
This approach forever reduced our interactions with the server-side to a set of key-value pairs (GET/POST parameters). Rather than looking for distributed object models (Smalltalk), etc. we went straight for easy to implement, in spite of the difficulties it caused for usability.
The Applet Era
- Java Applets (Sun wanted something to do with it)
- First "dynamic" content on web (in the browser)
- Solid architecture (security model, etc.) but never took hold (slow VM, bandwidth).
The Flash Era
- Started as a simple vector-animation solution (animated GIF killer)
- Competitor to "DHTML" for a while
- Now largely used for delivering video and audio content and games
- Deep concerns about openness (there isn't any), standards, usability, etc.
The JS Era
- Client side validation, animations, etc.
- "undersold" "much maligned"
- Most widely-deployed languages in existence.
The PHP Era
- The beginning of web development as a professional undertaking
- Now using technology for the web, rather than whatever is already there.
- Decent performance, but encourages poor practices.
- (Also spawned ASP)
The LAMP Era
- This is serious business now.
- Python catches up to PHP
- Perl still around
- Opensource web and DB servers, commoditisation of hosting, FCGI brings the "right tool for the job" mentality.
Not really a LAMP community anymore. The core community site (O'Reilly's ONLAMP, etc.) are gone. This "ice cube" has melted.
The Age of Frameworks
- Software engineers, computer scientists, information processing, etc. people bringing professionalism
- RoR, Django, etc., etc., etc.
- Codifying and building patterns, best practices. Treating web development like "real" software development.
- Increases productivity, reliability, etc. but brings possibilities of vendor dependency.
This has carried us into the present, but this last issue is where he thinks change will will drive the next change.
Looking back, there's a line at 1998 where Java, VRML, CGI, etc all trail off and Flash, JS, PHP take over.
Look at Apple's Project X
Dynamic, int langs are dominant. Languages built for the web face tought criticism. No technology lasts forever -- and that's a good thing.
Some trends picked out from people he knows and works with.
- Rails, Django, etc.
- jQuery, YUI, etc.
- CSS framworks,
- Typographic frameworks (TypeKit, sIFR, etc.)
Not just for mashups anumore.
Eat your own dogfood: APIs as system architecture. Building an API and implementing your own services on top of that. Flickr is a good example. Forces you to think about: what your system it; from a 3rd party dev's presepective; forced to write documentation; ...
Lets data that "doesn't fit the browser model" escape. They've seen this at Twitter: a lot of the data is webby (links, etc.) and lots and lots and lots isn't. The web aspect may not work as well as some other interface and environment (twitter.com vs Twitterific).
- Using the same language from backend to frontend.
- AppJet and others are paving the way.
- Works really well for AJAX-heavy applications (GMail, etc.)
- Made possible by Tamarin, SpiderMonkey, etc. being seperate and stable products.
** Code generations**
Using tools like GWT, Ruby helps, functional languages, you can avoid writing HTML/CSS/JS and generate it from language x.
Also used with DSLs to generate, metaprogram, backend code.
- HTML 5, JS 1.9
- New challenges too: mobile, geolocation, heavy-weight apps
The web outside the browser
Taking web development to other realms (for people who've only ever written for the web). Newer platforms leverage this: webOS, AIR, Titanium, Dashboard). Why build your own development model?
A year or so.
- Message queues connecting heterogenous components.
- Trickle-down SOA. Enterprisy but works well for high-performance web systems. Expecting to see this leveraged in frameworks. Also the "pushbutton" stuff Anil mentioned.
- Back to LAMP, but with a much, much wider diversity of languages.
- Also, the Cloud. Will reinforce these details: using services, etc. in the cloud. Storage all the way up to payment processing, user validation, etc. implemented as services in the cloud.
Currently: must have a webserver, database, framework. Soon: you'll "must" have a message queue.
Using databases for a lot of system-y stuff (queuing, etc.) just doesn't work.
- Google Native Video client.
- Getting video out of Flash.
- Mobile and desktop apps for various services.
Native and web platforms go through push-pull cycles. The Desktop tries to get into the browser (Applets, ActiveX, etc.) and the browser out (Dashboards, widgets, etc.)
The mobile web is not the web at all: that's not what people want and how they use it. People are shifting from "mobile web" to "mobile". We need to either build these mobile apps, or work with the people who do.
Wild ass prediction: functional languages will be the next big thing!
Lisp, Haskell, OCaml, etc. are finally building web tooling.
Newer languages like Scala (Lift) and Clojure are already productive and competitive for Web work.
Some newer languages are aimed specifically at the web (Arc, Ur). Aiming to be the PHP of the functional language landscape.
3 or 4 years down the road, you'll need to know a functional language (in the same way you need a bit of PHP, Python, etc. nmow).
The principal property is dynamism: all of the dominant technologies embrace dynamism, agility, etc. The philosophies about failing early, moving quickly, etc. has influenced us and our markets: no-one uses MS Office 97 on the web. We're all using the latest and greatest changes and features (and the users expect it: it's cultural now).
Tension There's a constant push and pull between dektop and web people. Just buy into these proprietary technologies and you'll get X, Y, Z. But the web people stick to stanard, open, approaches. Then this influences desktop, etc., etc.
Heterogeneity It's the largest heterogenious network we've ever assembled. More types of machines, languages, interfaces, etc. interacting with the trough each other. All you need it TCP/IP, HTTP, HTML/CSS/JS, etc. and you can do it.
Evolution The web is an egine for rapid evo -- tech and cultural -- we're focussed on the next search engine, next s. network etc.
Tools matter, languages matter. Don't wait to be told at a conference that "functional languages are the future." Go out, look, and learn for yourself. Find and help the next big tool. Help make the web more functional more beautiful, etc.
ASP and CF were in the gap and drove a lot of it. AS and JS aren't as seperate as all that. Only AS3 is statically typed. Tamarin is the Flash VM (donated to Mozilla). Flash as content, competitor to the browser.
(From the Adobe guy)
Why no mention of MS techologies?
Because no-one is using them in his world (but MySpace does, lols). Also a lot of following: PHP then ASP, Java then C#. They don't shape what we're doing and how we think about it: they follow it in their eco-system.
Where do the SproutCode, Capuccinuo, etc. fit in?
Not the sort of stuff that he does. But it seems that Capuccino is reinventing the wheel of Flash, but for Cocoa devs. It's impressive, but how many ObjC dev's actually want to do webdev.