blog by Peteris Erins
Month
We are moving everything to the web: stores, communication, applications, documents. Some of those moves really worked, mostly things that used to have physical boundaries.
But content on the web is lacking.
The web resume
The promise of the web resume is fantastic. Greater visibility, embedded microformats, interactivity, updates, and more.
Instead, chances are, your current resume is a Word document coupled with a PDF lying around in your filesystem. You update it every once in a while and send out the current version whenever somebody asks.
You might have a LinkedIn profile, but you probably don’t pass it on to employers. You might be getting a few approaches from head hunters, but the opportunities haven’t been right. You’re not entirely sure how to fit your experience in the LinkedIn format.
All these promises aren’t working out, but you don’t care. The PDF just looks better and it will look the same when you print it out.
Mobile apps
Web apps are increasingly, in theory, able to replicate the features of native apps. They needn’t pass through a market, are easy to update, etc. However, native apps still dominate on mobile.
There is something rigid and beautiful about a native app, that the web experience cannot replace (Sun gets very close, but I’m sure only at the cost of some serious man-hours).
The beauty of PDF
I find myself equally thorn about getting rid of my PDF resume. There is nothing special about it, it’s a simple tabular design, but the LaTeX typesetting and ease of editing are two features I cannot give up.
See, having only a web version means maintaining a print stylesheet, but getting LaTeX quality from a print.css is a challenge.
That elusive finish
There are examples that demonstrate that the web can be beautiful and fast, and powerful. But those examples have taken a lot of effort. Writing an app or a resume, you want to think about the content, not making sure it doesn’t disappoint on a browser. Because by default it does.
Lack of constraints
Part of the problem is that the web really can be a solution to anything. We can build a cute tool for list-menu and button fill web apps and we can build a stellar typesetting environment. Can we design for everything? Or are we forced to leave design to the web author?
Good design and quality is much harder to give up than we think. It could be done through new frameworks for the web, like we have seen impress.js and reveal.js provide some powerful competition to desktop presentation software. Ultimately though, the web needs to be beautiful by default. Like Cocoa, like LaTeX, like Keynote.
Disclaimer. This post was inspired by a conversation with @nickbarnwell.
After reading Conal Elliott’s recent Reimagining Matrices post on defining matrices as inductive linear maps, I was inspired to try out denotational design too. Daniel Rowlands pointed out that Conal’s approach is tensor-inspired and further generalizable, so I wanted to find out what that meant.
I set out to define tensors as nicely as I could. I didn’t end up needing to do equational reasoning, but the notion of having a type-level representation and a semantic function fit the domain well.
The definition I’m using is that, for a given vector space over field F (say real numbers), a tensor on the space is a multilinear map from some number of vectors and dual vectors to F. This raises the notion of type, where a tensor of type (n, m) accepts m vectors and n dual vectors.
A little bit of algebra shows that tensors can be represented with n vectors and m dual vectors. You can combine a dual vector and a vector to get a value in the field, so you need to match the numbers of vectors and dual vectors and take the product of the values.
This is a meaningful representation mathematically (taking tensor products of vector spaces and dual spaces), but we are content it gives us an inductive definition of tensors. We have a TUnit wrapper that gives a tensor from a vector and a TCoUnit wrapper that gives a tensor from a dual vector. We combine these using TProduct.
My first go is having the type as implicitly computed variables, but given you are using classical tensor operations, tensor type can be computed at compile-time. So I also tried to piece up a version using the shapeless library, its natural number types and sized collections. With help from Travis Brown on StackOverflow, I got it to work. I used Double for the field for simplicity and V as an arbitrary vector space over Double.
The code is below and includes a simple test for the typed version.
An extended title would read “temporal logic programming with explicit discrete time”. Temporal logics allow reasoning about time-varying propositions. By using a relational arithmetic implementation of time, we can to a limited extent express the core temporal operators in core.logic:
While I have used explicit time, I hope it is clear to the interested reader that this could readily be made into a miniKanren extension where all relations have implicit time. Some non-relational operators have been used for the examples, but an actual implementation involving the three temporal operators can be made relational, respecting some restrictions of context. The examples and the implementation was inspired by Templog, which is a temporal Prolog variant.
Yahoo was the first page on the internet I learned to use. It pleases me to see it going through a revitalization period. I expect them to be coming up with some exciting product changes and introductions soon. Before we see them commit to something though, I wanted to think with an open mind about what exactly Yahoo should be aiming for. I wanted to borrow the opinionated style of Andrew Kim, but digging slightly deeper. I not only went through product pages and Yahoo history, but also some of its developer and research pages to only suggest things that are consistent with Yahoo’s intellectual, infrastructural and artistic resource. Here are my notes from the process:
These strengths taken into account, Yahoo has a lot of separate product efforts that are tightly related. As an example, services like Pipes, myYahoo, alerts, and all aspects of news are all about up to date information. What if you had the power of Pipes and the accessibility of News?
Reading then about Yahoo’s streaming Hadoop job infrastructure and deep understanding of advertising and economic data, I think Yahoo is perfectly placed to deliver a dashboard solution. We need a big player to deliver this at scale, and none of the other giants have taken the leap. Google Now is a poke in that direction, I suppose, but it’s push-based and does not have an API for delivering custom information. Business and consumers should not have to roll out custom dashboard solutions much like they don’t provide their own e-mail clients.
I call it Horizon, to suggest access to what’s on the other side of the globe, i.e., beyond the horizon.
An HTML5 based, thoughtfully designed visualization element library would allow integration with others vendors’ and individuals’ data. A market for data, if you will.
Using Edward Tufte’s visualization principles, I chose a monochromatic, text and line heavy design where properties like size, shape and brightness directly reflect information novelty and importance.
Horizon scales from big screens to watches.
This would be relatively “safe” product, filling a clear gap in the market using very familiar technology. For the more distant future, I think Yahoo should innovate in interactive learning. It’s known for combining expert knowledge and insight with computer delivered data. Yahoo always had a bit more humanity to it than some of its competitors and that should be the bottom line going ahead.
Presented this at the Data Date Meetup in Riga earlier tonight. Program Induction is the act of generating programs. This is an example of a naive search in Haskell for arithmetic programs of one variable. It’s an exciting and growing field of AGI, and I expect big things from it.
Gave a talk last Thursday on Logic Programming at HNLondon, here is the video and the slides.
Wrote a miniature on leveraging arrows for composing probabilistic mappings. The arrow of probabilistic mappings.
I want to talk a little bit about the bootstrap principle. The book “Artificial Beings” by Jacques Pitrat helped me realize its ubiquity.
Programmers will be familiar with bootstrapping compilers. Have you heard of a C compiler being written in C? That makes a lot of sense — if you believe a language is great, you want to write its compiler in the same language. On another hand, isn’t it paradoxical? If we need the language to compile itself, how do we compile the compiler in the first place? Well, we resolve this by adding version information. You can use C 1.0 to write a compiler for C 2.0 And you will have compiled C 1.0 on a compiler written in C 0.0. But then how do you compile C.0? Just write the first compiler in assembly, or FORTRAN, or whatever was available. So treating different versions as different languages, bootstrapping is really just a cheat.
Evolution is another example of bootstrapping. Let’s do something grand. Let’s resolve the chicken and egg problem. The chicken and egg problem ponders what came first — the egg or the chicken. The paradox here is that to produce a chicken egg, you need a hen (that a chicken grows into) and to produce a chicken, you need a chicken egg. Now let’s look back at a version model. Let each chicken be assigned a version number. The first “chicken” that produced the first chicken egg 1.0 might have just been chicken version 0.999999. If you then need to know whether the egg was first or the chicken, it is reasonable to assign egg the same version number as the chicken that it produces. Then egg 1.0 came before chicken 1.0. And that’s it.
The problem is in our discrete labels on different species, they are sufficiently similar for us not to treat them as individuals for some purposes (same for minor editions of a programming language). However, we wouldn’t be able to draw exactly what the first chicken looked like or the first homo sapiens as those are fuzzy boundaries, naively applied. Aristotle never realized this as he wouldn’t step away from the discrete categories:
If there has been a first man he must have been born without father or mother – which is repugnant to nature. For there could not have been a first egg to give a beginning to birds, or there should have been a first bird which gave a beginning to eggs; for a bird comes from an egg.
Can we apply this somehow? A sample chicken & egg problem is social networks. To get a large user base, there needs to be good growth, but viral growth is proportional to the size of the user base. The solution (apart from paid advertising) is incremental growth. Few more users, little more growth, more users, etc. Incrementally versioning the user base and the growth trend.
So there you have it. Whenever you find a chicken and egg problem, start thinking more continuously and replace fuzzy boundaries with variables and versions.
For those who are interested in the inspiring example from the book, here it is. The author argued that the best first problem area for an artificial general intelligent being is creating artificial general intelligence (AGI). That would enable the being to grow and extend itself incrementally. The hypothesis being that AGI is just AI 3000.
Realized prolog’s dynamic assertions can be used to implement simple probabilistic programming with rejection sampling. Can probably be made much prettier, perhaps adding free variables as arguments of output or using clause manipulation. But this works.
What we are doing here is generating X and Y from two random dice rolls and adding them up. Then we want to sample some values of the sum given that rolling X resulted in a 2. We could just set X to 2 and sample Y only, but I’ve tried to do it right allowing, if needed, for X to depend on other random variables.
Try sample_cond(10, X).
For programming language junkies only:
PAKCS or the Portland Aachen Kiel Curry System is a state of the art Curry implementation. And Curry, well, is the standardized functional logic programming language (think Haskell + Prolog).
Trying to set it up was a pain as it didn’t work on Mac for some reason. Pretty straightforward in a vagrant linux VM though.
vagrant box add precise http://dl.dropbox.com/u/1537815/precise64.box
vagrant init precise
vagrant up
vagrant ssh
sudo apt-get install haskell-platform
sudo apt-get install swi-prolog
wget http://www.informatik.uni-kiel.de/~pakcs/download/pakcs_src.tar.gz
tar -zxvf pakcs_src.tar.gz
cd pakcs
make
finally add PATH="$PATH:~/pakcs/bin" to your .bashrc and run pakcs. You should see this:
______ __ _ _ ______ _______
| __ | / \ | | / / | ____| | _____| Portland Aachen Kiel
| | | | / /\ \ | |_/ / | | | |_____ Curry System
| |__| | / /__\ \ | _ | | | |_____ |
| ____| / ______ \ | | \ \ | |____ _____| | Version 1.10.1 (2)
|_| /_/ \_\ |_| \_\ |______| |_______|
An amazing talk on creativity, reinforcing convincingly the importance of persistance (grit) and taking breaks to allow for new insights.
Set up Distraction free markdown mode by Brett Terpstra in Sublime Text today. It’s heavily iA Writer inspired. I’ll be happily using it with Vintage mode on some longer writing.
Looks like this:
Here’s a closeup:
To set it up, type
cd ~/Library/Application\ Support/Sublime\ Text\ 2/Packages
git clone git://github.com/ttscoff/MarkdownEditing.git
then just open a markdown file.
Original blog post by author here.
Finished reading Onward yesterday. Covers the aftermath of Howard’s return as CEO in 2008, i.e., the ultimate recovery of Starbucks. Told with excessive spirit, it is a great story about leading an ambitious brand and purpose through a changing economy.
Here’s a taster:
“I’d like an iced grande latte with nonfat milk to the bottom line only, ice to the top with super-stiff foam with a dome lid.” That’s the drink Diane ordered almost religiously at our Coal Creek store in Washington. Brett in Bellevue was committed to two double-cupped venti breve, extra-hot, bone-dry cappuccinos. Customization was not only part of the Starbucks Experience, but also presented a fantastic opportunity to incentivize and reward our biggest fans.
Paper by 53 has recently caught my attention. It is a minimalist iPad drawing/sketching/mocking app that gives you a limited set of skeuomorphic utensils and colors to draw with. The utensils are carefully modeled to allow even unexperienced artists to produce appealing sketches (a la Instagram).
The Verge did a video interview with Georg Petschnigg where he talks about the philosophy behind paper. In fact, it is much more than a drawing app for hipsters, 53 aim to enable creativity in the digital world. They think of Paper to be a tool not just for artists, but also ultimately industrial designers, architects and even scientists. That is likely why they chose the in-app purchase mechanism for tool distribution.
Much like Instagram, a devoted community has sprung up posting their sketches using the tag #MadeWithPaper. Michael Rose @mmistakes is even doing portraits of Twitter avatars using Paper on this website.
Having tried it briefly, it does offer a very snappy and beautiful (thanks to OpenGL) experience. I would like to have something similar on the Nexus 7, but they would have to come up with an Android version and a zoom feature for that to be feasible. Until that happens, I’m sticking to Sketchbook pro.
And I do see people buying a stylus or even an iPad just for this app.
In a discussion group, a question about websites people frequent daily led me to explore the nature of news consumption. The pace of content production is ever increasing and new media sources are appearing daily. It is important to investigate, understand and streamline our consumption patterns.
Are you a fundamental analyst looking to for an edge in a dense space? Are you a devoted Hacker News reader who would like to explore other interests beyond startups and technology? Or perhaps you are still subscribed to dead trees and worried that your favorite paper is preparing to go digital? Read on.
I propose looking at news creation and distribution through five nearly orthogonal stages: observation, reporting, sharing, curation and consumption.
Observation or recording of an event or conception of an idea leads to new information that we are willing to distribute.
Through reporting, information is turned into a story or explanation. This could be through professional journalism, blogging or even public recitation.
News is shared via word of mouth, social networks and traditional media.
Selecting the most relevant content for consumption. We have seen social curation (Hacker News), hand-curation (traditional media providers) and machine-curation (Prismatic).
When news are digital, mode of consumption can be varied at the leisure of the consumer. From reading off a tablet while lounging at the couch to elevated real-time television dashboards and voice-over, we expect the same content to be responsively accessible in many ways.
Consumption is more a feature of our environment context rather than a conscious choice, so the most interesting stage for us as content consumers to explore is curation.
Social curation websites like reddit or Hacker News allow users to post news which are then rated by other users through upvotes and comments. Top rated news will show up on the homepage.
hckrnews is an unofficial Hacker News client.
Social networks like Google+ are examples too. You hand-curate and follow a set of people and you get all the news they share along with everything else.
Machine curation is an even more recent paradigm where news are selected by machine learning algorithms. In addition to numeric social metrics such as shares and likes they can be looking at influence scores, topic relevance, source credibility among other things. Your Facebook stream is an example of this.
Prismatic lets you select both topics and individual content providers (blogs or news publishers). It then uses social signals from people in your networks to curate, yielding a highly personalized real-time stream.
Google finance aggregates news relevant to financial markets. Sources are presumably selected by experts.
Many people still source from a set of RSS feeds. There are tools like Newsblur that permit filtering by tags and other metadata allowing you to fine-tune what types of content from a given provider you are interested in.
Using web technologies, it is very easy to combine streams of content and apps like Pulse have risen to the occasion.
Here are the important properties of each curation method:
Two metrics surface that can help compare curation methods. Relevance and quality. In hand-curation and social curation, relevance and quality are coupled in the selection process, however, machine curation starts with topical content it thinks is relevant and tries to extract the highest quality content out of that batch. This natural decoupling is an important feature of digital news distribution.
To understand how content moves between news channels, consider these diagrams.
RSS doesn’t need much of an explanation. Sources in, content out.
In Twitter we can distinguish between pure content sources and distributors, which tend to reshare or retweet content found somewhere else.
Prismatic uses both definite content sources and social networks for curation.
Finally, lets look at how we can leverage the properties of each of these channels to get a relevant and flexible news stream.
Given RSS’ “lossless” property, we reserve it for blogs and media where we expect to or require to read every single thing. For me, that’s a set of data blogs and then a few others that put posts out very rarely and are niche enough to never appear in curated streams. I will have a pass through Newsblur every two weeks or so. Google Reader would be a popular alternative.
I also read the Hacker News front page. It’s not a lot to read and is usually highly targeted. If your interests are outside tech, you might find an interesting subreddit or a mailing list.
Twitter is great to get a lot of content sources together. Many reddit channels and RSS feeds have twitter profiles. Facebook would be useful if you have similar interests to your friends. I find even when that is the case, my friends tend to post mostly entertainment or casual reading, so I prefer Twitter. Google+ is another option, but currently it may not integrate very well with aggregators. Consider it more of an end-point.
Finally I use Prismatic to fuzzily feed in a couple more content sources and all my topics of interest. It works surprisingly well and if you follow people who post relevant content, it will surface here and you won’t miss out on important news even if you do not read your whole Twitter stream (from what I understand hardly anybody does so these days, I certainly can’t). I really like the elasticity, you know that for however much time you have available, you will get the top news. Wavii is worth looking at if you need an alternative.
For the record, I mainly read either on my tablet or Mac and occasionally delegate to Readability.
I hope you’re inspired to at least give some of these services a good look and see if they would work for you. You know the concepts now and it’s just a question of fitting them to your interests and constraints.
After getting a Nexus 7 + LunaTik Touch Pen + Autodesk Sketchbook Pro combo, I’ve been trying to do some drawing. I really enjoyed doing drawing back as a child and there is something very nostalgic about doing it even in this new medium.
Here’s the idea:
An early sketch of a weird monument at the Plex.
I’ve been thinking recently about issues of software maintainability and how we just start over too much in software. Recall the idea from Structure and Interpretation of Computer Programs that the key tool in computer science is building up black box abstractions. A complete abstraction layer allows us to move away from the prior words altogether, giving us a language of higher order with the same or sufficient expressive power.
I will propose that the number of stacked layers put to actual use defines a metric for the progress of software development.
Let’s start at the physical “hardware” level, which we can call level 0. A human who is running an algorithm in their head or on a piece of paper is operating at level 0. Similarly, any Rube Goldberg type machine set up in an ad hoc way from arbitrary pieces is still level 0. Yes, an abacus or similar primitive hardware is also level 0, as there is no abstraction language, it’s just a memory aid and you have to directly change the hardware to operate on it.
It all starts in 1801 when Joseph-Marie Jacquard invents punch cards. Punch cards allowed human s to program in the language of holes. Different programs can be created and edited on the same unaltered hardware.
Circa 1948, Nathaniel Rochester writes the first symbolic assembler for the IBM 701. Even with all the calculators and the Turing machine that have been invented since punchcards, this is the first case of a layer 2 abstraction. One could argue that assembly language rewrites to machine code rather directly, but in practice this was a significant push. The alphanumeric mnemonics and ease of development were key.
Grace Hopper writes the first compiler for the A-0 System. I do not have sources to verify this was written in assembly language, and it seems too early to have been.
John W. Backus leads the development of the Fortran compiler, arguably the first complete compiler. Given that IBM introduced the first assembler, this was likely written in assembly, however, it probably produced machine code rather than assembly code, so could as well be considered as another assembler.
Very shortly following this, however, the Fortran compiler was used to create the Fortran List Processing Language or FLPL, the precursor to LISP.
Guido van Rossum invents Python, one of the most famous interpreted languages today.
More importantly, we get documented HTTP, it works out to become the communications protocol that enables modern browsers.
The first browsers appeared in the eighties, way before HTTP. However, they were mostly for displaying hypertext.
James Gosling invents Java. Here we have a famous language meant to run on a virtual machine using a byte code compiler.
Soon after Javascript follows suit competing with Java in the browser.
I described some of these later programming languages, since they represent important ideas and developments, however, any programming language can in principle be translated to machine code directly and with relative ease. Programming languages do not really build on top of each other as much as their compilers are inevitably implemented by different languages. They are mostly independent efforts and no language has yet rendered all its precedents irrelevant.
Nope.
I don’t really know. Programming by telling the computer what to do? Programming by thinking about what the computer should do? These would definitely qualify as paradigm shifts. Textual natural language input is probably the first thing we will see.
Now, I know very little about software history and honestly did not conduct sufficient research to present these levels with any certainty. I would love to make this more complete, please reach out if you know earlier manifestations of any levels. Nor do I believe, especially after going through the history of computing, that the concept of the abstraction layer number is well defined. Nonetheless, it is a curious notion.
Also, I feel I have moved away from counting layers to paradigms as I ran into some fallacies. Hopefully this is still interesting to think about.
Wikipedia, mostly.
(20.09.12) For a much cleaner approach, see Tekmo’s comment on reddit.
For the first time in my life I’m hacking on corporate Java code and, well, ever so occasionally it can be frustrating. The Google Guava libraries make Java programming more bearable by introducing common helper functions, immutable data structures and a few more gadgets, but their lack of orthogonality leaks out whenever what you need is not in the library.
A common scenario in Java is making a comparison function for a class that has a couple of comparable constituents. You impose some sort of lexicographic order and compare using nested assignments, nested if else statements or the trinary operator. In this example, lets say we are in a function, so we can leverage return. It’s still pretty verbose.
Guava introduces a ComparisonChain class, that enables a declarative approach.
Can we repeat this in Haskell? There is a nice and short solution exploiting that Ordering is a Monoid instance.
However, there is a problem with this approach. Lists are homogenous in Haskell, so we would not be able to compare elements of different types within one lexicographic comparison. Instead, we can create a micro DSL using the Either monad. It’s useful because Left, normally used for exceptions, can “exit” a do statement, which is exactly what we need when we get a non equal comparison any time in the chain.
Much better.
My Google Drive just finished preparing. Mashable reports:
Like Microsoft’s SkyDrive and Box, Google Drive offers in-browser access to files and folders, including document editing via Google Docs.
And like SkyDrive, Box and iCloud, third-party applications can plug into Google Drive to retrieve or store files. This makes keeping apps synchronized across devices and platforms much more seamless.
..
Google is pricing Google Drive at a VERY aggressive level. For $30 a year ($2.50 a month), users get 25GB to use for Google Drive and Picasa, plus 25GB of Gmail storage.
This is more than what Amazon and Microsoft charge for an additional 20GB, but less than the price of Dropbox, Apple and Box.net.
We appreciate more virtual breathing room, but does Google Drive offer anything more for the casual user? Looking back to Dropbox synchronization, collaboration and public URLs were the main three features I liked. It seems Drive is lacking the latter – it doesn’t work as a static site server off the bat. Even making images public requires a roundabout way compared to Dropbox’s drag & drop public folder. Google Docs integration hardly makes up for it.
Assuming Google will implement public URLs or make a good reason not to, it looks as if Drive will at least simplify many more Google and non-Google services to come. Do be excited, if not for the present then for the future.
I’m moving my blog from my homepage to tumblr. It usually goes the other way around with self-hosted blogs favored and associated with freedom in style, content ownership and distribution. While I see the benefits, I am using other social networks quite a bit, so it does not make much sense to just host my own blog posts. Especially considering that they are probably the least private of the things I share.
This is the first part of a bigger experiment of building a homepage to collect pieces of externally hosted content produced or shared by me. In other words, remember these websites where people share their newest tweets on the homepage? I want the homepage to be just a collection of profiles and activity from other websites.
What are the benefits? I don’t have to write any code to set up tools, such as plain text editing, tags, comments and archive. A lot of non-essential features come for free, for example, with tumblr, I can write a post from my phone. That would not be a priority for a self-hosted blog. Writing posts in a popular platform also helps intelligent web applications to discover and parse my content. In this case, I am willing to trade away a little freedom for more time and better distribution.
Stay tuned for the actual website.