Another Word For It Patrick Durusau on Topic Maps and Semantic Diversity

October 4, 2011

Buckets of Sockets

Filed under: Erlang,Software — Patrick Durusau @ 7:56 pm

Buckets of Sockets

OK, so some of the stuff I have pointed to lately hasn’t been “hard core.” šŸ˜‰

This should give you some ideas about building communications (including servers) in connection with topic maps.

From the webpage:

So far we’ve had some fun dealing with Erlang itself, barely communicating to the outside world, if only by text files that we read here and there. As much of relationships with yourself might be fun, it’s time to get out of our lair and start talking to the rest of the world.

This chapter will cover three components of using sockets: IO lists, UDP sockets and TCP sockets. IO lists aren’t extremely complex as a topic. They’re just a clever way to efficiently build strings to be sent over sockets and other Erlang drivers.

September 22, 2011

Riak 1.0.0 RC 1

Filed under: Erlang,Riak — Patrick Durusau @ 6:27 pm

Riak 1.0.0 RC 1

From the post:

We are pleased to announce the first release candidate for Riak 1.0.0 is now available.

The packages are available on our downloads page: http://downloads.basho.com/riak/riak-1.0.0rc1/

As a release candidate, we consider this to be a functionally complete representation of Riak 1.0.0. From now until the 1.0.0 release, only critical bug fixes will be merged into the repository. We would like to thank everyone who took the time to download, install, and run the pre-releases. The Riak community has always been one of the great strengths of Riak, and this release period has been no different with feedback and bug reports we’ve been given.

Cool!

September 14, 2011

Leveling Up in The Process Quest

Filed under: Erlang — Patrick Durusau @ 7:00 pm

Leveling Up in The Process Quest: The Hiccups of Appups and Relups

I won’t reproduce the image that “learn you some Erlang for great good” uses for a failed update, you will have to visit the blog page to see for yourself.

I can quote the first couple of paragraphs that sets the background for it:

Doing some code hot-loading is one of the simplest things in Erlang. You recompile, make a fully-qualified function call, and then enjoy. Doing it right and safe is much more difficult, though.

There is one very simple challenge that makes code reloading problematic. Let’s use our amazing Erlang-programming brain and have it imagine a gen_server process. This process has a handle_cast/2 function that accepts one kind of argument. I update it to one that takes a different kind of argument, compile it, push it in production. All is fine and dandy, but because we have an application that we don’t want to shut down, we decide to load it on the production VM to make it run.

I suspect that Erlang or something close to it will become the norm in the not too distant future. Mostly because there won’t be an opportunity to “catch up” on all the data streams in the event of re-loading the application. May have buffering in the event of a reader failure but not system wide.

September 7, 2011

An Open Source Platform for Virtual Supercomputing

Filed under: Cloud Computing,Erlang,GPU,Supercomputing — Patrick Durusau @ 6:55 pm

An Open Source Platform for Virtual Supercomputing, Michael Feldman reports:

Erlang Solutions and Massive Solutions will soon launch a new cloud platform for high performance computing. Last month they announced their intent to bring a virtual supercomputer (VSC) product to market, the idea being to enable customers to share their HPC resources either externally or internally, in a cloud-like manner, all under the banner of open source software.

…

The platform will be based on Clustrx and Xpandrx, two HPC software operating systems that were the result of several years of work done by Erlang Solutions, based in the UK, and Massive Solutions, based in Gibraltar. Massive Solutions has been the driving force behind the development of these two OS’s, using Erlang language technology developed by its partner.

In a nutshell, Clustrx is an HPC operating system, or more accurately, middleware, which sits atop Linux, providing the management and monitoring functions for supercomputer clusters. It is run on its own small server farm of one or more nodes, which are connected to the compute servers that make up the HPC cluster. The separation between management and compute enables it to support all the major Linux distros as well as Windows HPC Server. There is a distinct Clustrx-based version of Linux for the compute side as well, called Compute Based Linux.

A couple of things to note from within the article:

The only limitation to this model is its dependency on the underlying capabilities of Linux. For example, although Xpandrx is GPU-aware, since GPU virtualization is not yet supported in any Linux distros, the VSC platform can’t support virtualization of those resources. More exotic HPC hardware technology would, likewise, be out of the virtual loop.

The common denominator for VSC is Erlang, not just the company, but the language http://www.erlang.org/, which is designed for programming massively scalable systems. The Erlang runtime has built-in to support for things like concurrency, distribution and fault tolerance. As such, it is particularly suitable for HPC system software and large-scale interprocess communication, which is why both Clustrx and Xpandrx are implemented in the language.

As computing power and access to computing power increases, have you seen an increase in robust (in your view) topic map applications?

September 5, 2011

Erlang – 3 Slide decks

Filed under: Actor-Based,Erlang — Patrick Durusau @ 7:28 pm

I encountered three (3) slide decks on Erlang today:

Mohamed Samy presents two sessions on Erlang:

Erlang Session 1 – General introduction, sequential Erlang.

Erlang Session 2 – Concurrency, Actors

Despite the titles, there was no session 3.

Which writing those up, I saw:

Concurrency Oriented Programming in Erlang A more advanced view of Erlang and its possibilities.

August 25, 2011

Erlang Community Site

Filed under: Erlang,Marketing — Patrick Durusau @ 7:02 pm

Erlang Commnity site: www.trapexit.org

Interesting collection of links to various Erlang resources.

Includes Try Erlang site, where you can try Erlang in your browser.

I have seen topic maps displayed in web browsers. I have seen fairly ugly topic map editors in web browsers. No, don’t think I have seen a “Try Topic Maps” type site. Have I just missed it?

Thoughts? Suggestions?

July 24, 2011

A practical introduction to MochiWeb

Filed under: Erlang,Web Applications — Patrick Durusau @ 6:47 pm

A practical introduction to MochiWeb

From the post:

Bob Ippolito, creator or MochiWeb, describes it as ā€œan Erlang library for building lightweight HTTP serversā€. Itā€™s not a framework: it doesnā€™t come with URL dispatch, templating or data persistence. Despite not having an official website or narrative documentation, MochiWeb is a popular choice to build web services in Erlang. The purpose of this article is to help you to get started by gradually building a microframework featuring templates and URL dispatch. Persistence will not be covered.

Just in case you are interested in building web services in Erlang for your topic map application.

July 19, 2011

Build your own internet search engine

Filed under: Erlang,Search Algorithms,Search Engines,Searching — Patrick Durusau @ 7:53 pm

Build your own internet search engine by Daniel Himmelein.

Uses Erlang but also surveys the Apache search stack.

Not that you have to roll your own search engine but it will give you a different appreciate for the issues they face.

Update: Build your own internet search engine – Part 2

I ran across part 2 while cleaning up at year’s end. Enjoy!

July 18, 2011

The Joy of Erlang; Or, How To Ride A Toruk

Filed under: Erlang,Marketing,Topic Maps — Patrick Durusau @ 6:42 pm

The Joy of Erlang; Or, How To Ride A Toruk by Evan Miller.

From the post:

In the movie Avatar, there’s this big badass bird-brained pterodactyl thing called a Toruk that the main character must learn to ride in order to regain the trust of the blue people. As a general rule, Toruks do not like to be ridden, but if you fight one, subdue it, and then link your Blue Man ponytail to the Toruk’s ptero-tail, you get to own the thing for life. Owning a Toruk is awesome; it’s like owning a flying car you can control with your mind, which comes in handy when battling large chemical companies, impressing future colleagues, or delivering a pizza. But learning to ride a Toruk is dangerous, and very few people succeed.

I like to think of the Erlang programming language as a Toruk. Most people are frightened of Erlang. Legends of its abilities abound. In order to master it, you have to fight it, subdue it, and (finally) link your mind to it. But assuming you survive, you then get to control the world’s most advanced server platform, usually without even having to think. And let me tell you: riding a Toruk is great fun.

This guide is designed to teach you the Erlang state of mind, so that you are not afraid to go off and commandeer a Toruk of your own. I am going to introduce only a handful of Erlang language features, but we’re going to use them to solve a host of practical problems. The purpose is to give you the desire and confidence to go out and master the rest of the language yourself.

You are welcome to type the examples into your own Erlang shell and play around with them, but examples are foremost designed to be read. I recommend printing this document out and perusing it in a comfortable chair, away from email, compilers, 3-D movies, and other distractions.

Do you think people view topic maps as a Toruk?

How would you train them to ride rather than be eaten?

July 17, 2011

Highly Scalable Erlang Web Apps

Filed under: Erlang,Marketing,Software — Patrick Durusau @ 7:26 pm

Highly Scalable Erlang Web Apps by Yurii Rashkovskii.

From the post:

Erlang is not well known for itā€™s ability for writing Web applications on the front-end; however, it can be incredibly powerful for writing scalable and highly scalable. Yurii Rashkovskii, creator of Beam.js and Erlagner.org is helping to change that with a laundry list of Erlang open source projects and libraries which make writing powerful and scalable Web applications back possible in Erlang. Yurii Rashkovskii recently presented on some of the powerful frameworks he has presented at the Erlang Factory in London and shares some of his projects and their powerful abilities.

In addition to useful information about Erlang web apps, Yurii says:

If one would look at my current list of open source Erlang projects, they might seem like a pile of unrelated stuff, but thereā€™s actually a very basic idea behind most (if not all) of these projects. The idea is that if we want to make Erlang a much more attractive platform for other developers, we should act more on befriending adjacent communities, instead of directly competing with them. (emphasis added)

Is that a useful way to think about topic map applications?

July 13, 2011

Scala for the Curious Erlang Programmer

Filed under: Erlang,Scala — Patrick Durusau @ 7:28 pm

Dean Wampler ā€“ Scala for the Curious Erlang Programmer

From the description:

Scala is a statically-typed, hybrid functional and object-oriented language for the JVM. The Scala standard library includes an Erlang- inspired Actors library. In this talk, I’ll discuss how Scala compares and contrasts to Erlang, highlighting the advantages and disadvantages of each language for particular needs. For example, we’ll discuss the pros and cons of a rich type system and static typing in Scala. We’ll discuss ways that Scala is perhaps more general purpose than Erlang, but not as powerful in the areas where Erlang excels.

Always useful to choose the right tool for a task. Including semantics as understood by users.

You may also enjoy Dean’s Polyglotprogramming site, with links to his presentations and blog.

July 7, 2011

_Let_It_Crash_

Filed under: Erlang — Patrick Durusau @ 4:29 pm

_Let_It_Crash_

Pavlo Baron’s highly entertaining slides from SEACOM ’11.

Useful for making the argument against purely defensive programming but also planning for what to do when crashes occur.

The images add a lot to the presentation. I need to remember that for future presentations.

June 20, 2011

Erlang and First-Person Shooters

Filed under: Erlang — Patrick Durusau @ 3:35 pm

Erlang and First-Person Shooters

Use of Erlang by DemonWare to run an online gaming site with millions of concurrent users.

Mostly an overview.

Makes me wonder:

  1. How the information needs in a first-person shooter game are different, if at all, from the information needs of a topic map user?
  2. Can a war game simulation be used to demonstrate the utility of topic maps in a military situation?
  3. Has semantic impedance been modeled in war game simulations? (Or gathered based on actual experience?)

June 11, 2011

Lessons Learned in Erlang Land

Filed under: Erlang — Patrick Durusau @ 12:41 pm

Lessons Learned in Erlang Land

From the post:

Kresten Krab Thorup, CTO of the Danish software development company Trifork delivered a keynote on Erlang at Gotocon 2011. Thorup is sharing this presentation on his lessons learned in Erlang on SlideShare.

Thorup talked about cloud computing, multi-core processors, the need for fault tolerance and more are necessitating a shift away from the object oriented programming paradigm. He suggests that actor programming is the best way to deal with modern programming challenges, and talks about why Erlang in particular is well suited for modern development.

The slides are useful but would be even more useful if a video of the presentation were posted as well.

May 21, 2011

Erlang – Give it a try! (Marketing TM idea?)

Filed under: Erlang,Marketing — Patrick Durusau @ 5:24 pm

Erlang – Give it a try!

I just spot checked this online shell but it looks interesting.

Might be the sort of thing to get someone interested in Erlang.

Shows just enough to awaken interest in its capabilities.

Reminds me of a mother who read just enough of a story to capture a child’s interest and refused to read the rest of it. So the child had to learn to read it on their own, to find out how the story continued.

Maybe we need to do the same to market topic maps? Topic map enough content in an area that users will want to extend the topic map to make it more useful to them. To complete the story as it were.

I know what interests me, but it isn’t any more marketable than topic maps of 18th century castrati or similar obscurities. Fundable but not marketable.

Suggestions for what might prove to be popular topic maps?

May 17, 2011

Riak Search Explained

Filed under: Erlang,Riak — Patrick Durusau @ 2:49 pm

Riak Search Explained

From Alex Popescu myNoSQL, pointer to an explanation of Riak search.

Covers:

  • Full-text search built on Riak Core
  • Easy to use (start, join, done)
  • Solr compatible interface (just mentioned)
  • Riak KV integration (bulk of the presentation)

Focus of the presentation is to integrate full-text search with Riak Core with another application.

Riak Search is a superset of Riak KV (only install one).

Riak search source code.

Eventually Consistent?

Filed under: Erlang,Riak — Patrick Durusau @ 2:48 pm

statebox, an eventually consistent data model for Erlang (and Riak)

From the post:

When you choose an eventually consistent data store you’re prioritizing availability and partition tolerance over consistency, but this doesn’t mean your application has to be inconsistent. What it does mean is that you have to move your conflict resolution from writes to reads. Riak does almost all of the hard work for you [2], but if it’s not acceptable to discard some writes then you will have to set allow_mult to true on your bucket(s) and handle siblings [3] from your application. In some cases, this might be trivial. For example, if you have a set and only support adding to that set, then a merge operation is just the union of those two sets.

statebox is my solution to this problem. It bundles the value with repeatable operations [4] and provides a means to automatically resolve conflicts. Usage of statebox feels much more declarative than imperative. Instead of modifying the values yourself, you provide statebox with a list of operations and it will apply them to create a new statebox. This is necessary because it may apply this operation again at a later time when resolving a conflict between siblings on read.

I like that, “move conflict resolution from writes to reads.”

Sounds like where ISO/IEC 13250 points out two or more topic links maybe merged, and/or applications may process and/or render them as if they have been merged. (5.2.1 Topic Link Architectural Form)

Which fits your topic maps use case better? Consistency (one representative per subject) on write or read?

May 13, 2011

3 Free E-Books and a Tutorial on Erlang

Filed under: Erlang — Patrick Durusau @ 7:23 pm

3 Free E-Books and a Tutorial on Erlang.

From ReadWrite Hack a collection of resources on Erlang.

You really need to see the “classic” movie promoting Erlang for telephony.

Maybe a contest for the “classic” movie promoting topic maps? Suggestions?

May 11, 2011

Introduction to programming in Erlang, Part 1

Filed under: Erlang — Patrick Durusau @ 6:57 pm

Introduction to programming in Erlang, Part 1

IBM’s developerWorks has discovered Erlang.

Summary:

Erlang is a multi-purpose programming language used primarily for developing concurrent and distributed systems. It began as a proprietary programming language used by Ericsson for telephony and communications applications. Released as open source in 1998, Erlang has become more popular in recent years thanks to its use in high profile projects, such as the Facebook chat system, and in innovative open source projects, such as the CouchDB document-oriented database management system. In this article, you will learn about Erlang, and how its functional programming style compares with other programming paradigms such as imperative, procedural and object-oriented programming. You will learn how to create your first program, a Fibonacci recursive function. Next, you will go through the basics of the Erlang language, which can be difficult at first for those used to C, C++, Javaā„¢, and Python.

May 8, 2011

Nitrogen Web Framework

Filed under: Erlang,Riak — Patrick Durusau @ 6:14 pm

Nitrogen Web Framework

From the website:

Nitrogen Web Framework is the fastest way to develop interactive web applications in full-stack Erlang.

Whether you are working with Riak (also programmed in Erlang) or not, this web framework may be of interest.

April 29, 2011

Building Erlang Applications with Rebar

Filed under: Erlang — Patrick Durusau @ 1:13 pm

Since Erlang underlies Riak, a NoSQL distributed key-value store, I thought this might be of interest:

Building Erlang Applications with Rebar

From the description:

Rebar is an Open Source project that provides a set of standardized build tools for OTP applications and releases. This talk will explore how to use Rebar in a typical development environment for everything from simple Erlang code to port drivers and embedded Erlang servers.

Talk Objectives: Introduce the major features and functionality that rebar provides to Erlang developers. Examine the architecture of rebar and discuss how it can be extended.

Target Audience: Any Erlang developer interested in using or extending rebar for their build system.

Additional references:

Rebar: Erlang Build Tool

Erlang App. Management with Rebar (another tutorial)

Rebar Mailing List

April 23, 2011

Learn You Some Erlang For Great Good!

Filed under: Erlang — Patrick Durusau @ 8:21 pm

Learn You Some Erlang For Great Good!

A free online resource for learning Erlang.

April 8, 2011

Riak Core – An Erlang Distributed Systems Toolkit

Filed under: Erlang,Riak — Patrick Durusau @ 7:20 pm

Riak Core – An Erlang Distributed Systems Toolkit

Abstract:

Riak Core is the distributed systems foundation for the Riak distributed database and the Riak Search full-text indexing system. Riak Core provides a proven architecture for building scalable, distributed applications quickly. This talk will cover the origins of Riak Core, the abstractions and functionality it provides, and some guidance on building distributed systems.

Something for those interested in building distributed topic map applications.

March 29, 2011

Phoebus: Erlang-based Implementation of Google’s Pregel

Filed under: Erlang,Graphs — Patrick Durusau @ 12:48 pm

Phoebus: Erlang-based Implementation of Google’s Pregel

From Alex Popescu’s myNoSQL a report on another parallel graph database engine.

You can also see the source code at the project site.

The project site points to: Pregel: a system for large-scale graph processing (2009), a one page summary about Pregel, but you may find: Pregel: a system for large-scale graph processing (2010), at eleven (11) pages of interesting detail more helpful.

BTW, the following two citations are actually the same paper, literally:

http://dx.doi.org/10.1145/1583991.1584010

@inproceedings{Malewicz:2009:PSL:1583991.1584010,
author = {Malewicz, Grzegorz and Austern, Matthew H. and Bik, Aart J.C. and Dehnert, James C. and Horn, Ilan and Leiser, Naty and Czajkowski, Grzegorz},
title = {Pregel: a system for large-scale graph processing},
booktitle = {Proceedings of the twenty-first annual symposium on Parallelism in algorithms and architectures},
series = {SPAA ’09},
year = {2009},
isbn = {978-1-60558-606-9},
location = {Calgary, AB, Canada},
pages = {48–48},
numpages = {1},
url = {http://doi.acm.org/10.1145/1583991.1584010},
doi = {http://doi.acm.org/10.1145/1583991.1584010},
acmid = {1584010},
publisher = {ACM},
address = {New York, NY, USA},
keywords = {distributed computing, graph algorithms},
}

and,

http://dx.doi.org/10.1145/1582716.1582723

@inproceedings{Malewicz:2009:PSL:1582716.1582723,
author = {Malewicz, Grzegorz and Austern, Matthew H. and Bik, Aart J.C. and Dehnert, James C. and Horn, Ilan and Leiser, Naty and Czajkowski, Grzegorz},
title = {Pregel: a system for large-scale graph processing},
booktitle = {Proceedings of the 28th ACM symposium on Principles of distributed computing},
series = {PODC ’09},
year = {2009},
isbn = {978-1-60558-396-9},
location = {Calgary, AB, Canada},
pages = {6–6},
numpages = {1},
url = {http://doi.acm.org/10.1145/1582716.1582723},
doi = {http://doi.acm.org/10.1145/1582716.1582723},
acmid = {1582723},
publisher = {ACM},
address = {New York, NY, USA},
keywords = {distributed computing, graph algorithms},
}

Different DOIs, different citations statistics, same text.

Just so you don’t include both in a bibliography.

March 16, 2011

Topic Map Server Language?

Filed under: Erlang,Topic Map Software — Patrick Durusau @ 3:21 pm

I ran across a comparison of the Apache web server and Yaws the other day.

Apache vs. Yaws

I haven’t given web servers much thought and had someone asked (apologies to friends at MS) I would have said Apache, just by default.

It is what I remember from web work when I was concerned about that sort of thing.

Anyway, I am looking at this comparison and Apache falls over on its side at about 8,000 concurrent sessions and Yaws is humming along at 80,000.

That’s quite a difference.

Enough of a difference that Erlang, the language in which Yaws was written, should be seriously considered for topic map engines.

March 8, 2011

Tenth ACM SIGPLAN Erlang Workshop

Filed under: Conferences,Erlang — Patrick Durusau @ 9:57 am

Tenth ACM SIGPLAN Erlang Workshop

From the website:

Erlang is a concurrent, distributed functional programming language aimed at systems with requirements on massive concurrency, soft real time response, fault tolerance, and high availability. It has been available as open source for over 10 years, creating a community that actively contributes to its already existing rich set of libraries and applications. Originally created for telecom applications, its usage has spread to other domains including e-commerce, banking, databases, and computer telephony and messaging.

Erlang programs are today among the largest applications written in any functional programming language. These applications offer new opportunities to evaluate functional programming and functional programming methods on a very large scale and suggest new problems for the research community to solve.

This workshop will bring together the open source, academic, and industrial programming communities of Erlang. It will enable participants to familiarize themselves with recent developments on new techniques and tools tailored to Erlang, novel applications, draw lessons from users’ experiences and identify research problems and common areas relevant to the practice of Erlang and functional programming.

Important Dates

Submission deadline: Friday, June 3, 2011
Author notification: Friday, June 17, 2011
Final submission for the publisher: Friday, July 13, 2011
Workshop date: Friday, September 23, 2011

February 25, 2011

Learn You Some Erlang For Great Good!

Filed under: Erlang — Patrick Durusau @ 4:17 pm

Learn You Some Erlang For Great Good!

I mention this site as a preface to asking if anyone is working on a topic map implementation in Erlang?

I suppose I have been influenced by Barta’s arguments for a functional approach.

In part because what subjects you see and what properties they possess are determined by what you ask to see.

Not that other approaches have a different answer, they just aren’t as transparent about it.

It is perfectly fine to have a point of view on the world, just don’t confuse your point of view with the world.
*****
PS: The message passing capabilities should also be of interest for distributed as well as non-distributed topic map applications. Imagine a proxy that broadcasts the identity of the subject it represents.

February 15, 2011

Webmail for Millions, Powered by Erlang

Filed under: Erlang,Hibari,NoSQL — Patrick Durusau @ 11:38 am

Webmail for Millions, Powered by Erlang

From the website:

Scott Lystig Fritchie presents the architecture and lessons learned implementing a webmail system in Erlang, using UBF and Hibari, a distributed key-value store, to accommodate a large user base.

UBF? (new to me)

From http://norton.github.com/ubf:

UBF is the “Universal Binary Format”, designed and implemented by Joe Armstrong. UBF is a language for transporting and describing complex data structures across a network. It has three components:

  • UBF(A) is a “language neutral” data transport format, roughly equivalent to well-formed XML.
  • UBF(B) is a programming language for describing types in UBF(A) and protocols between clients and servers. This layer is typically called the “protocol contract”. UBF(B) is roughly equivalent to Verified XML, XML-schemas, SOAP and WDSL.
  • UBF(C) is a meta-level protocol used between a UBF client and a UBF server.

Potential lessons for those developing scalable topic map applications.

February 9, 2011

Erjang – A JVM-based Erlang VM

Filed under: Erjang,Erlang — Patrick Durusau @ 5:48 pm

Erjang-A-JVM-based-Erlang-VM by Kresten Krab Thorup

Presentation, slides and mp3 on Erjang. Kresten blogs about this project at: http://www.javalimit.com/.

Erlang and Erjang are not the basis for universal answers to all topic map needs.

However, robust message passing systems, such as Erlang and Erjang support, can figure into some topic map based solutions.

Just as there is no one method of subject identity that fits all purposes, there is no one topic map solution that fits all needs.

Discussions of solutions should always start with exploration and documentation of your requirements, not the capabilities of particular software, whether commercial, open source or home grown.

There will be time for you to learn about various software packages and why their capabilities matter more than your requirements later in the process.

February 4, 2011

Erlang Factory – SF Bay Area 2010
2011 Coming Up!

Filed under: Conferences,CS Lectures,Erlang — Patrick Durusau @ 8:51 am

Erlang Factory – SF Bay Area 2010

From the website:

The Erlang Factory SFBay Area was a resounding success with 34 speakers delivering talks in three tracks to an audience of over 120! The event was held at the San Francisco Airport Hilton and proved to be the largest Erlang event in the US so far, overtaking last year’s despite the continuing effects of the downturn in the marketplace.

There were delegates and speakers from Argentina, Brazil, Israel, Japan, Canada, Sweden, Denmark, Germany, France, and Italy as well as from all parts of the US. This resulted in a very stimulating environment where Erlang was discussed and user’s experiences compared.

The long term and successful use of Erlang in telecommunications makes me suspect that it has a lot to offer designers of distributed topic map systems.

The presentations and slides from the 2010 conference are available for your viewing.

The Erlang Factory – SF Bay Area 2011 conference is coming up, 21-25 March 2011.

Please post a note if you are working on topic maps using Erlang. Thanks!

« Newer Posts — Older Posts »

Powered by WordPress