Archive for the ‘Programming’ Category

Functional Javascript

Tuesday, June 18th, 2013

Functional Javascript by Michael Fogus.

From the post:

After a seemingly endless journey, the publication of Functional JavaScript is complete and books have found their way into peoples’ homes. Below is a list of useful links related to the book:

Enjoy.

More summer reading material!

From NAND to Tetris

Monday, June 17th, 2013

From NAND to Tetris: Building a Modern Computer from First Principles

From the website:

The official companion web site of Nand2Tetris courses

And of the book The Elements of Computing Systems, MIT Press, By Noam Nisan and Shimon Schocken.

The site contains all the software tools and project materials necessary to build a general-purpose computer system from the ground up. We also provide a set of lectures designed to support a typical course on the subject.

The materials are aimed at students, instructors, and self-learners. Everything is free and open-source; as long as you operate in a non-profit educational setting, you are welcome to modify and use our materials as you see fit.

Kris Geusebroek had me musing this morning about static database structures being a legacy of a shortage of CPU cycles. (I Mapreduced a Neo store [Legacy of CPU Shortages?])

What other limitations are due to system design?

This course could start you in the direction of answering that question.

Semantic Diversity – Special Characters

Monday, June 17th, 2013

neo4j/cypher/Lucene: Dealing with special characters by Mark Needham.

Mark outlines how to handle “special characters” in Lucene (indexer for Neo4j), only to find that an escape character for a Lucene query is also a special character for Cypher, which itself must be escaped.

There is a chart in Mastering Regular Expressions by Jeffrey E F Friedl of “special” characters but that doesn’t cover all the internal parsing choices software.

Over the last sixty plus years there has been little progress towards a common set of “special” characters in computer science.

Handling of “special” characters lies at the heart of accessing data and all programs have code to account for them.

With no common agreement on “special” characters, what reason would you offer to expect convergence elsewhere?

Clojure Cookbook

Thursday, June 13th, 2013

Clojure Cookbook

From the webpage:

Clojure Cookbook is coming

And we need your help.

We want this O’Reilly cookbook to be a comprehensive resource containing the collective wisdom of Clojurists from every domain. That’s why we want to write it together, as a community.

Share some code. Explain it. Be a part of Clojure history.

Clojure Cookbook

Cool!

GitHub clojure-cookbook.

Anatomy of Programming Languages

Wednesday, June 12th, 2013

Anatomy of Programming Languages by William R. Cook.

From the Introduction:

In order to understand programming languages, it is useful to spend some time thinking about languages in general. Usually we treat language like the air we breathe: it is everywhere but it is invisible. I say that language is invisible because we are usually more focused on the message, or the content, that is being conveyed than on the structure and mechanisms of the language itself. Even when we focus on our use of language, for example in writing a paper or a poem, we are still mostly focused on the message we want to convey, while working with (or struggling with) the rules and vocabulary of the language as a given set of constraints. The goal is to work around and avoid problems. A good language is invisible, allowing us to speak and write our intent clearly and creatively.

The same is true for programming. Usually we have some important goal in mind when writing a program, and the programming language is a vehicle to achieve the goal. In some cases the language may fail us, by acting as an impediment or obstacle rather than an enabler. The normal reaction in such situations is to work around the problem and move on.

The study of language, including the study of programming languages, requires a different focus. We must examine the language itself, as an artifact. What are its rules? What is the vocabulary? How do different parts of the language work together to convey meaning? A user of a language has an implicit understanding of answers to these questions. But to really study language we must create an explicit description of the answers to these questions.

The concepts of structure and meaning have technical names. The structure of a language is called its syntax. The rules that defined the meaning of a language are called semantics. Syntax is a particular way to structure information, while semantics can be viewed as a mapping from syntax to its meaning, or interpretation. The meaning of a program is usually some form of behavior, because programs do things. Fortunately, as programmers we are adept at describing the structure of information, and at creating mappings between different kinds of information and behaviors. This is what data structures and functions/procedures are for.

Thus the primary technique in these notes is to use programming to study programming languages. In other words, we will write programs to represent and manipulate programs. One general term for this activity is metaprogramming. A metaprogram is any program whose input or output is a program. Familiar examples of metaprograms include compilers, interpreters, virtual machines. In this course we will read, write and discuss many metaprograms.

I have only started to read this book but to say:

A good language is invisible, allowing us to speak and write our intent clearly and creatively.

May describe a good quality for a language but it is also the source of much difficulty.

Our use of a word may be perfectly clear to us but that does not mean it is clear to others.

For example:

Verbal Confusion

Wood you believe that I didn’t no
About homophones until too daze ago?
That day in hour class in groups of for,
We had to come up with won or more.

Mary new six; enough to pass,
But my ate homophones lead the class.
Then a thought ran threw my head,
”Urn a living from homophones,” it said.

I guess I just sat and staired into space.
My hole life seamed to fall into place.
Our school’s principle happened to come buy,
And asked about the look in my I.

“Sir,” said I as bowled as could bee,
My future roll I clearly see.”
“Sun,” said he, “move write ahead,
Set sail on your coarse, Don’t be mislead.”

I herd that gnus with grate delight.
I will study homophones both day and knight,
For weaks and months, through thick oar thin,
I’ll pursue my goal. Eye no aisle win.

—George E. Coon
The Reading Teacher, April, 1976

I first saw this at Verbal Confusion.

Improving your Erlang programming skills doing katas

Tuesday, June 11th, 2013

Improving your Erlang programming skills doing katas by Paolo D’incau.

From the post:

There is one sure thing about programming: you should try to improve your set of skills in a regular way. There are several different methods to achieve this kind of result: reading books and blogs, working on your own pet project and doing pair programming are all very good examples of this, but today I want to introduce you code kata. What is a kata? Well, since you ask, you won’t mind if I digress for a while first!

What is a kata?

In Japanese, the word kata is used to describe choreographed patterns of movements that are practised in solo or possibly with a partner. Kata are especially applied in martial arts because they do represent a way of teaching and practicing in a systematic approach rather than as individuals in a clumsy manner. If the concept of kata is still not clear (shame on me!) you just need to watch again the movie Karate Kid. For the whole movie Mr. Miyagi San teaches Daniel LaRusso the importance of kata and we know that Miyagi San is always right!

The basic concept behind kata is fairly simple: if we keep on practicing in a repetitive manner we can acquire the ability to execute movements without hesitation and to adapt them to a set of different situations without any fear. Pretty cool uh?

Coming back to the good old world of software developers (and especially Erlang ones) we may ask ourselves: “how can we apply the concept of kata to our daily routine?”. David Thomas (one of the authors of “The Pragmatic Programmer”) introduced the concept of Code Kata which is a programming exercise useful to improve our knowledge and skills through practice and repetition. The interesting point of code kata is that usually the exercises proposed are easy and can be implemented on a step-by-step fashion.

A chance to learn/improve your Erlang skills and to learn a good new habit! (Bad habits are easy to acquire.)

Enjoy!

Adventures in Advanced Symbolic Programming

Saturday, June 1st, 2013

Adventures in Advanced Symbolic Programming by Gerald Jay Sussman with Pavel Panchekha.

Description:

Concepts and techniques for the design and implementation of large software systems that can be adapted to uses not anticipated by the designer. Applications include compilers, computer-algebra systems, deductive systems, and some artificial intelligence applications. Means for decoupling goals from strategy. Mechanisms for implementing additive data-directed invocation. Working with partially-specified entities. Managing multiple viewpoints. Topics include combinators, generic operations, pattern matching, pattern-directed invocation, rule systems, backtracking, dependencies, indeterminacy, memoization, constraint propagation, and incremental refinement. Substantial weekly programming assignments are an integral part of the subject.

I was searching for updates on the Revised Report on the Propagator Model when I discovered this course and its readings page.

From the readings page:

Propagator Language and System

Suggestion: Don’t cheat yourself by focusing too narrowly. All of the reading material is worthwhile.

Scala 2013 Overview

Friday, May 31st, 2013

Scala 2013 Overview by Sagie Davidovich.

An impressive set of slides on Scala.

Work through all of them and you won’t be a Scala expert but well on your way.

I first saw this at Nice Scala Tutorial by Danny Bickson.

Writing a Minimal Working Example (MWE) in R

Thursday, May 30th, 2013

Writing a Minimal Working Example (MWE) in R by Jared Knowles.

From the post:

How to Ask for Help using R

The key to getting good help with an R problem is to provide a minimally working reproducible example (MWRE). Making an MWRE is really easy with R, and it will help ensure that those helping you can identify the source of the error, and ideally submit to you back the corrected code to fix the error instead of sending you hunting for code that works. To have an MWRE you need the following items:

  • a minimal dataset that produces the error
  • the minimal runnable code necessary to produce the data, run on the dataset provided
  • the necessary information on the used packages, R version, and system
  • a seed value, if random properties are part of the code

Let’s look at the tools available in R to help us create each of these components quickly and easily.

R specific but the general principles apply to any support question.

Pointers to other language/software specific instructions for support questions?

Even heavier requirements obtain in development environments:

stacktrace

Why Would #1 Spy on #2?

Wednesday, May 29th, 2013

Confirmation: China has a 50+ Petaflop system.

That confirmation casts even more doubt on the constant drum roll of “China spying on the U.S.” allegations.

Who wants to spy on second place technology?

The further U.S.-based technology falls behind, due to the lack of investment in R&D by government and industry, expect the the hysterical accusations against China and others to ramp up.

Can’t possibly be that three month profit goals and lowering government spending led to a self-inflicted lack of R&D.

Must be someone stealing the technology we didn’t invest to invent. Has to be. ;-)

The new Chinese system is a prick to the delusional American Exceptionalism balloon.

There will be others.

The Charm of Being Small (4K)

Tuesday, May 28th, 2013

white one – Making of

From the post:

white one is my first 4k intro and my first serious demoscene production (as far as something like that can be serious). I’m new to C coding and to sizecoding in particular, so there were a lot of things to be learned which I’ll try to summarize here. Download and run the executable (nvidia only, sorry) or watch the video capture first:

A 4k intro is a executable file of at most 4 kilobytes (4096 bytes) that generates video and audio. That is, it puts something moving on your screen and something audible on your speakers. The finished product runs for a few minutes, has some coherent theme and design and ideally, sound and visual effects complement each other. On top of that, it’s a technical challenge: It’s impossible to store 3D models, textures or sound samples in 4 kilobytes, so you have to generate these things at runtime if you need them.

Overwhelmed by the impossibility of all this I started messing around.

I had been lurking on a few demoparties, but never released anything nontrivial – i do know some OpenGL, but i am normally coding Lisp which tends to produce executables that are measured in megabytes. Obviously, that had to change if i wanted to contribute a small intro. Playing with the GL Shading Language had always been fun for me, so it was clear that something shader-heavy was the only option. And I had some experience with C from microcontroller hacking.

(…)

While researching visualizations I encountered this jewel.

Good summer fun and perhaps an incentive to have coding catch up with hardware.

Lots of hardware can make even poor code run acceptably, but imagine good code with lots of hardware.

BTW, as an additional resource, see: demoscene.info.

…How to program Ruzzle

Monday, May 27th, 2013

Graph search, algorithmic optimization, and word games: How to program Ruzzle

The graph processing aspects of programming Ruzzle are interesting.

With a suitable dictionary, this could be converted into a spelling puzzle for not so recent languages.

Or for that matter, a spelling puzzle for vocabularies in general (albeit some might require a larger board).

Graph Databases and Software Metrics & Analysis

Friday, May 24th, 2013

Graph Databases and Software Metrics & Analysis by Michael Hunger

From the post:

This is the first in a series of blog posts that discuss the usage of a graph database like Neo4j to store, compute and visualize a variety of software metrics and other types of software analytics (method call hierarchies, transitive clojure, critical path analysis, volatility & code quality). Follow up posts by different contributors will be linked from this one.

Everyone who works in software development comes across software metrics at some point.

Just because of curiosity about the quality or complexity of the code we’ve written, or a real interest to improve quality and reduce technical debt, there are many reasons.

In general there are many ways of approaching this topic, from just gathering and rendering statistics in diagrams to visualizing the structure of programs and systems.

There are a number of commercial and free tools available that compute software metrics and help expose the current trend in your projects development.

Software metrics can cover different areas. Computing cyclomatic complexity, analysing dependencies or call traces is probably easy, using statical analysis to find smaller or larger issues is more involved and detecting code smells can be an interesting challenge in AST parsing.

Interesting work on using graph databases (here Neo4j) for software analysis.

Be sure to see the resources listed at the end of the post.

Introduction to Artificial Intelligence (Berkeley CS188.1x)

Wednesday, May 22nd, 2013

Introduction to Artificial Intelligence (Berkeley CS188.1x)

The schedule for CS188.2x hasn’t been announced, yet.

In the meantime, you can register for CS188.1x and peruse the videos, exercises, etc. while you wait for the second part of the course.

From the description:

CS188.1x is a new online adaptation of the first half of UC Berkeley’s CS188: Introduction to Artificial Intelligence. The on-campus version of this upper division computer science course draws about 600 Berkeley students each year.

Artificial intelligence is already all around you, from web search to video games. AI methods plan your driving directions, filter your spam, and focus your cameras on faces. AI lets you guide your phone with your voice and read foreign newspapers in English. Beyond today’s applications, AI is at the core of many new technologies that will shape our future. From self-driving cars to household robots, advancements in AI help transform science fiction into real systems.

CS188.1x focuses on Behavior from Computation. It will introduce the basic ideas and techniques underlying the design of intelligent computer systems. A specific emphasis will be on the statistical and decision–theoretic modeling paradigm. By the end of this course, you will have built autonomous agents that efficiently make decisions in stochastic and in adversarial settings. CS188.2x (to follow CS188.1x, precise date to be determined) will cover Reasoning and Learning. With this additional machinery your agents will be able to draw inferences in uncertain environments and optimize actions for arbitrary reward structures. Your machine learning algorithms will classify handwritten digits and photographs. The techniques you learn in CS188x apply to a wide variety of artificial intelligence problems and will serve as the foundation for further study in any application area you choose to pursue.

Graph Representation – Edge List

Saturday, May 18th, 2013

Graph Representation – Edge List

From the post:

An Edge List is a form of representation for a graph. It maintains a list of all the edges in the graph. For each edge, it keeps track of the 2 connecting vertices as well as the weight between them.

Followed by C++ code as an example.

A hypergraph would require tracking of 3 or more connected nodes.

EarSketch

Monday, May 13th, 2013

EarSketch: computational music remixing and sharing as a tool to drive engagement and interest in computing

From the “about” page:

EarSketch engages students in computing principles through collaborative computational music composition and remixing. It consists of an integrated curriculum, software toolset, and social media website. The EarSketch curriculum targets introductory high school and college computing education. The software toolset enables students to create music by manipulating loops, composing beats, and applying effects with Python code. The social media website invites students to upload their music and source code, view other students’ work, and create derivative musical remixes from other students’ code. EarSketch is built on top of Reaper, an intuitive digital audio workstation (DAW) program comparable to those used in professional recording studios.

EarSketch is designed to enable student creativity, to enhance collaboration, and to leverage cultural relevance. This focus has created unique advantages for our approach to computing education:

  • EarSketch leverages musical remixing as it relates to popular musical forms, such as hip hop, and to industry-standard methods of music production, in an attempt to connect to students in a culturally relevant fashion that spans gender, ethnicity, and socioeconomic status.
  • EarSketch focuses on the level of beats, loops, and effects more than individual notes, enabling students with no background in music theory or composition to begin creating personally relevant music immediately, with a focus on higher-level musical concepts such as formal organization, texture, and mixing.
  • The EarSketch social media site allows a tight coupling between code sharing / reuse and the musical practice of remixing. Students can grab code snippets from other projects and directly inject them into their own work, modifying them to fit their idiosyncratic musical ideas.
  • EarSketch builds on professional development techniques using an industry-relevant, text-based programming language (Python), giving students concrete skills directly applicable to further study.

EarSketch is a National Science Foundation-funded initiative that was created to motivate students to consider further study and careers in computer science. The program, now in its second year, is focused on groups traditionally underrepresented in computing, but with an approach that is intended to have broad appeal.

I encountered EarSketch when I found: Creating your own effects: 8. Graph data structures.

Curious how you would use music to introduce topic maps and/or semantic integration?

5 Best Free Scala Books

Wednesday, May 1st, 2013

5 Best Free Scala Books

From the post:

Scala is a modern, object-functional, multi-paradigm, Java-based programming and scripting language that is released under the BSD license. It blends the functional and object-oriented programming models. Scala introduces several innovative language constructs. It improves on Java’s support for object-oriented programming by traits, which are stackable and cannot have constructor parameters. It also offers closures, a feature that dynamic languages like Python and Ruby have adopted.

Scala is particularly useful for building cloud-based/deliverable Software as a Service (SaaS) online applications, and is also proficient to develop traditional, imperative code.

Scala helps programmers write tighter code. It uses a number of techniques to cut down on unnecessary syntax, which helps to make code succint. Typically, code sizes are reduced by an order of 2 or 3 compared to an equivalent Java application.

The focus of this article is to select the finest Scala books which are available to download for free. So get reading and learning.

Covers:

Programming in Scala by Martin Odersky, Lex Spoon, and Bill Venners.

Programming Scala by Dean Wampler, Alex Payne.

Exploring Lift by Derek Chen-Becker, Marius Danciu and Tyler Weir.

Scala by Example by Martin Odersky.

A Scala Tutorial for Java Programmers by Michel Schinz and Philipp Haller.

I first saw this at: DZone.

Algorithms, 4th Edition

Wednesday, May 1st, 2013

Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.

Here you will find excerpts from the text, Java code and solutions to some exercises on:

  1. Fundamentals
  2. Sorting
  3. Searching
  4. Graphs
  5. Strings
  6. Context

My latest from Sedgewick is almost a decade old so I may need to upgrade to the latest version.

At almost 1,000 pages (976 to be exact), it may push me towards a Kindle reader. ;-)

Qi4j SDK Release 2.0

Sunday, April 28th, 2013

Qi4j SDK Release 2.0

From the post:

After nearly 2 years of hard work, the Qi4j Community today launched its second generation Composite Oriented Programming framework.

Qi4j is Composite Oriented Programming for the Java platform. It is a top-down approach to write business applications in a maintainable and efficient manner. Qi4j let you focus on the business domain, removing most impedance mismatches in software development, such as object-relation mapping, overlapping concerns and testability.

Qi4j’s main areas of excellence are its enforcement of application layering and modularization, the typed and generic AOP approach, affinity based dependency injection, persistence management, indexing and query subsystems, but there are much more.

The 2.0 release is practically a re-write of the entire runtime, according to co-founder Niclas Hedhman; “Although we are breaking compatibility in many select areas, most 1.4 applications can be converted with relatively few changes.”. He continues; “These changes are necessary for the next set of planned features, including full Scala integration, the upcoming JDK8 and Event Sourcing integrated into the persistence model.”

“It has been a bumpy ride to get this release out the door.”, said Paul Merlin, the 2.0 Release Manager, “but we are determined that Qi4j represents the best technological platform for Java to create applications with high business value.” Not only has the community re-crafted a remarkable codebase, but also created a brand new website, fully integrated with the new Gradle build process.

See: http://qi4j.org and http://qi4j.org/2.0/.

Principles of Composite Oriented Programming:

  • Behavior depends on Context
  • Decoupling is a virtue
  • Business Rules matters more
  • Classes are dead, long live interfaces

“Behavior depends on Context” sounds a lot like identity depends on context, either of what the object represents or a user.

Does your application capture context for data or its users? If so, what does it do with that information?

Speak of the devil,… I just mentioned Peter Neubauer in a prior post, then I see his tweet on Qi4j. ;-)

Strange Loop 2013

Saturday, April 27th, 2013

Strange Loop 2013

Dates:

  • Call for presentation opens: Apr 15th, 2013
  • Call for presentation ends: May 9, 2013
  • Speakers notified by: May 17, 2013
  • Registration opens: May 20, 2013
  • Conference dates: Sept 18-20th, 2013

From the webpage:

Below is some guidance on the kinds of topics we are seeking and have historically accepted.

  • Frequently accepted or desired topics: functional programming, logic programming, dynamic/scripting languages, new or emerging languages, data structures, concurrency, database internals, NoSQL databases, key/value stores, big data, distributed computing, queues, asynchronous or dataflow concurrency, STM, web frameworks, web architecture, performance, virtual machines, mobile frameworks, native apps, security, biologically inspired computing, hardware/software interaction, historical topics.
  • Sometimes accepted (depends on topic): Java, C#, testing frameworks, monads
  • Rarely accepted (nothing wrong with these, but other confs cover them well): Agile, JavaFX, J2EE, Spring, PHP, ASP, Perl, design, layout, entrepreneurship and startups, game programming

It isn’t clear why Strange Loop claims to have “archives:”

2009201020112012

As far as I can tell, these are listings with bios of prior presentations, but no substantive content.

Am I missing something?

Bad Practices

Friday, April 26th, 2013

Why Most People Don’t Follow Best Practices by Kendra Little.

Posted in a MS SQL Server context but the lesson applies to software, systems, and processes alike:

Unfortunately, human nature makes people persist all sorts of bad practices. I find everything in the wild from weekly reboots to crazy settings in Windows and SQL Server that damage performance and can cause outages. When I ask why the settings are in place, I usually hear a story that goes like this:

  • Once upon a time, in a land far far away there was a problem
  • The people of the land were very unhappy
  • A bunch of changes were made
  • Some of the changes were recommended by someone on the internet. We think.
  • The problem went away
  • The people of the land were happier
  • We hunkered down and just hoped the problem would never come back
  • The people of the land have been growing more and more unhappy over time again

Most of the time “best practices” are implemented to try and avoid pain rather than to configure things well. And most of the time they aren’t thought out in terms of long term performance. Most people haven’t really implemented any best practices, they’ve just reacted to situations.

How are the people of the land near you?

History of the Modern GPU Series

Wednesday, April 24th, 2013

History of the Modern GPU Series

From the post:

Graham Singer over at Techspot posted a series of articles a few weeks ago covering the history of the modern GPU. It is well-written and in-depth.

For GPU affectionados, this is a nice read. There are 4 parts to the series:

  1. Part 1: (1976 – 1995) The Early Days of 3D Consumer Graphics
  2. Part 2: (1995 – 1999) 3Dfx Voodoo: The Game-changer
  3. Part 3: (2000 – 2006) The Nvidia vs. ATI Era Begins
  4. Part 4: (2006 – 2013) The Modern GPU: Stream processing units a.k.a. GPGPU

Just in case you are excited about the GPU news reported below, a bit of history might not hurt.

;-)

Ack 2.0 enhances the “grep for source code”

Tuesday, April 23rd, 2013

Ack 2.0 enhances the “grep for source code”

From the post:

The developers of ack have released version 2.0 of their grep-like tool optimised for searching source code. Described as “designed for programmers”, ack has been available since 2005 and is based on Perl’s regular expressions engine. It minimises false positives by ignoring version control directories by default and has flexible highlighting for matches. The newly released ack 2.0 introduces a more flexible identification system, better support for ackrc configuration files and the ability to read the list of files to be searched from stdin.

Its developers say that ack is designed to perform in a similar fashion to GNU grep but to improve on it when searching source code repositories. The programs web site at beyondgrep.com lists a number of reasons why programmers might want to use ack instead of grep when searching through source code, the least of which being that the ack command is quicker to type than grep. But ack brings a lot more to the table than that as it is specifically designed to deal with source code and understand a large number of programming languages and tools such as build systems and version control software.

Is there any ongoing discussion of semantic searching for source code?

List of Machine Learning APIs

Wednesday, April 17th, 2013

List of Machine Learning APIs

From the post:

Wikipedia defines Machine Learning as “a branch of artificial intelligence that deals with the construction and study of systems that can learn from data.”

Below is a compilation of APIs that have benefited from Machine Learning in one way or another, we truly are living in the future so strap into your rocketship and prepare for blastoff.

Interesting collection.

Worth reviewing for “assists” to human curators working with data.

And a rich hunting ground for head to head competitions against human curated data.

I first saw this at Alex Popescu’s List of Machine Learning APIs.

In-Memory Computing

Wednesday, April 17th, 2013

Why In-Memory Computing Is Cheaper And Changes Everything by Timo Elliott.

From the post:

What is the difference? Database engines today do I/O. So if they want to get a record, they read. If they want to write a record, they write, update, delete, etc. The application, which in this case is a DBMS, thinks that it’s always writing to disk. If that record that they’re reading and writing happens to be in flash, it will certainly be faster, but it’s still reading and writing. Even if I’ve cached it in DRAM, it’s the same thing: I’m still reading and writing.

What we’re talking about here is the actual database is physically in in-memory. I’m doing a fetch to get data and not a read. So the logic of the database changes. That’s what in-memory is about as opposed to the traditional types of computing.

Why is it time for in-memory computing?

Why now? The most important thing is this: DRAM costs are dropping about 32% every 12 months. Things are getting bigger, and costs are getting lower. If you looked at the price of a Dell server with a terabyte of memory three years ago, it was almost $100,000 on their internet site. Today, a server with more cores — sixteen instead of twelve — and a terabyte of DRAM, costs less than $40,000.

In-memory results in lower total cost of ownership

So the costs of this stuff is not outrageous. For those of you who don’t understand storage, I always get into this argument: the total cost of acquisition of an in-memory system is likely higher than a storage system. There’s no question. But the total cost of TCO is lower – because you don’t need storage people to manage memory. There are no LUNs [logical unit numbers]: all the things your storage technicians do goes away.

People cost more than hardware and software – a lot more. So the TCO is lower. And also, by the way, power: one study IBM did showed that memory is 99% less power than spinning disks. So unless you happen to be an electric company, that’s going to mean a lot to you. Cooling is lower, everything is lower.

Timo makes a good case for in-memory computing but I have a slightly different question.

If both data and program are stored in memory, where is the distinction between program and data?

Or in topic map terms, can’t we then speak about subject identities in the program and even in data at particular points in the program?

That could be a very powerful tool for controlling program behavior and re-purposing data at different stages of processing.

Visual Computing: Geometry, Graphics, and Vision (source code)

Friday, April 12th, 2013

Frank Nielsen blogged today that he had posted the C++ source code for “Visual Computing: Geometry, Graphics, and Vision.”

See: Source codes for all chapters of “Visual Computing: Geometry, Graphics, and Vision”

New demos are reported to be on the way.

The Pragmatic Haskeller

Saturday, April 6th, 2013

Announcing The Pragmatic Haskeller by Alfredo Di Napoli.

From the post:

We are working programmers. Even though we are carried away by the beauty and formalism of functional languages, at the end of the day we still need to get the job done. The Haskell community has been accused during the years of navel gazing, and usually the misconception is that “Haskell is an academic language, but you can’t tackle real world problem with it”.

Despite internet is full of fantastic resources for learning Haskell (including the awesome and recently-released School of Haskell) I wanted to use a peculiar approach: I tried to create a web application in a similar fashion of what I would have done during my everyday job in Scala, to see if I was able to replicate a large subset of the features normally present in my Scala apps. Not only was the experiment a success, but I finally had the chance of experimenting with a lot of cool libraries which were in my “to-play-with-list” for a while. So without further ado I’m happy to announce The Pragmatic Haskeller, a collection of small building blocks for creating a full-fledged webapp:

https://github.com/cakesolutions/the-pragmatic-haskeller

As you might notice, we have a lot of small subfolders. Each folder is a self-contained, working, incremental example experimenting with a new library or technique. Even though you could rush and play with each app all at once, I aim to write a dedicated blog post to each sub-project, introducing the used library, in a similar way of what Oliver Charles did with 24 days of Hackage, with the difference we’ll use the same example episode after episode, until transforming our naive bunch of modules into a complete app.

If the future of big data is with functional programming, where’s yours?

Elm

Tuesday, April 2nd, 2013

The Elm Programming Language

From the webpage:

Elm is a functional reactive programming (FRP) language that compiles to HTML, CSS, and JS. FRP is a concise and elegant way to create highly interactive applications and avoid callbacks.

The hyperlinks for “create,” “highly,” “interactive,” and “applictions,” all lead to examples using Elm.

I never was much of a Pong player. More of a Missile Command and Boulder Dash fan. Still, it is an interesting demonstration. (Wasn’t working when I tried it.)

Yes, another programming language. ;-)

But, it does look lite enough to encourage experimentation with interfaces.

Whether it is lite enough to keep people from feeling “invested” in prior interface choices only time will tell.

Not for everyone but I can imagine a topic map interface that offers design patterns in UML notation which are extended/completed by a user.

Or interfaces that are drawing kits of nodes and edges. Some predefined, some you define.

Or interfaces with text boxes and reasonable names for their contents.

Or other variations I cannot imagine.

Could be “lite” or “feature rich,” although I lean towards the “lite” side.

Wherever you come down on that continuum, topic maps need interfaces as varied as its users.

Introduction to C and C++

Monday, March 25th, 2013

Introduction to C and C++

Description:

This course provides a fast-paced introduction to the C and C++ programming languages. You will learn the required background knowledge, including memory management, pointers, preprocessor macros, object-oriented programming, and how to find bugs when you inevitably use any of those incorrectly. There will be daily assignments and a small-scale individual project.

This course is offered during the Independent Activities Period (IAP), which is a special 4-week term at MIT that runs from the first week of January until the end of the month.

Just in case you want a deeper understanding of bugs that enable hacking or how to avoid creating such bugs in the first place.

Methods of Proof — Induction

Saturday, March 23rd, 2013

Methods of Proof — Induction by Jeremy Kun.

Jeremy covers proof by induction in the final post for his “proof” series.

Induction is used to prove statements about natural numbers (positive integers).

Lars Marius Garshol recently concluded slides on big data with:

  • Vast potential
    • to both big data and machine learning
  • Very difficult to realize that potential
    • requires mathematics, which nobody knows
  • We need to wake up!

Big Data 101 by Lars Marius Garshol.

If you want to step up your game with big data, you will need to master mathematics.

Excel and other software can do mathematics but can’t choose the mathematics to apply.

That requires you.