Posts with keyword: programming+languages

                          The New Pico Engine Is Ready for Use

                          The new pico engine is nearly feature complete and being used in a wide variety of settings. I'm declaring it ready for use.
                          Continue reading...

                          We're Teaching Programming Wrong

                          Event-based programming is more natural for non-programmers than imperative or object-oriented styles.
                          Continue reading...

                          Rebuilding KRL

                          I'm reimplmenting KRE, the evaluation engine that makes picos work. Here's the initial plan and a call for (paid) help.
                          Continue reading...

                          Languages Have Power

                          Programming language choice matters. Languages have the power to push us out of familiar ways of working and into new ways of thinking. But using a language out of the mainstream takes real courage.
                          Continue reading...

                          Why KRL?

                          A lot of people ask me why I invented Kinetic Rule Language (KRL) instead of just using an existing language. There are a lot of answers to that question, but I want to get to some specifics. Tools shape how we think and work. I learned long ago that the best way to think differently about a problem is to create a nomenclature that describes and illuminates the new domain. KRL is a rule-based language that is custom built for the domain of event-based applications that operate on real-time data in the cloud. KRL was designed from the ground
                          Continue reading...

                          The Kynetx Rule Language has Modules

                          KRL (Kynetx Rule Language) started out as a fairly small domain specific language for augmenting Web pages. We integrated with several online services (like geolocation, weather, and so on) to make what we were doing simpler to write. Later, as KRL grew, we added more integrations with Web APIs and services like Twitter. We've increased the abstraction capabilities of the language by adding first-class functions. Lately we've realized that many of the native integrations of external APIs we've done could--and should--be done by developers working in KRL. If only they had a way to encapsulate and share them! Now
                          Continue reading...

                          Language Design Gives Leverage

                          Last Friday I spoke at the Utah Open Souce Conference on designing and building domain specific languages (DSLs). The slide from my talk are online (PDF). Our experience building KRL served as the catalyst and gave me concrete examples to talk about even though I'd hesitate to call it a DSL anymore. Yesteday, I had an experience which reinforced my enthusiasm for building languages. Writing the post on building event intermediaries, thinking through the patterns, and talking to some of the Kynetx engineers who have the most experience with raising explicit events led to thoughts about how to generalize
                          Continue reading...

                          Getting Quotes and Comments Right

                          Poor decisions in language design are tough to hide because fixing them is akin to changing the API of your library. You can hide all kinds of sins below the covers, but errors in the syntax and semantics can only be fixed by confessing those sins to the world. Consider this a confession. One of the niggling little details of Kynetx Rule Language has been comment treatment. The parser we user, Parse::RecDescent, does not include a lexer--tokens are specified as regular expressions in productions. That works fine for everything but comments. Because there's no lexer, you can't flag a
                          Continue reading...

                          Programming the Internet: Reactive Systems, Events, and KRL

                          Imagine walking into Borders and having your smartphone alert you to the fact that the book you put on your Amazon wish list this morning is available right now and on sale. As another example, think about an application that gathers relevant articles from your RSS and Twitter feeds based on searches you've performed or that are related to an email your received from a friend today. These examples show the power that can be achieved when we start programming the Internet and not just the Web. There's no reason that clients in different domains (like your smartphone and
                          Continue reading...

                          KNS Build 351: FLWR Comes to KRL

                          One of the big features missing from KRL as a rule language is a foreach statement that allows looping. Build 351 of KNS (released today) fixes that problem. The thing that kept holding me back was confusion on my part about the best way to add it and how it should work. The problem was that I wanted, thought KRL needed, more than just looping. I wanted full-blown FLWOR statements (foreach, let, where, order by, result). I realized one day on a bike ride that the entire rule ought to be a FLWOR statement and that meant that the
                          Continue reading...

                          Persistent Variables in KRL: Threading Sites Together

                          Yesterday I released build 325 of Kynetx Network Services (KNS) which includes a significant addition to the feature set of Kynetx Rule Language (KRL): persistent variables. Persistent variables allow KRL rulesets to store and react to data over multiple visits. This data isn't personally identifying information, but rather the kind of information that makes writing intelligent Web applications easier. Here's an example: an information box placed on a Web site can now have a "don't show this to me again" check box and act accordingly. Persistent variables, or just persistents, will ultimately come in two flavors: Entity variables store
                          Continue reading...

                          You're Gonna Need It

                          Normally, I subscribe to the "YNGNI" philosophy: You're Not Gonna Need It. The idea is don't over engineer things because you'll likely spend a lot of time on things that never get used. This post is about an exception to that rule that I wish I'd followed. When I started designing KRL, there wasn't much in the way of variable scoping and it didn't really need it. Each rule was a local scope and there were no global variables. Only one ruleset ever operated at a time. Consequently, I took the easy route and instead of designing a proper
                          Continue reading...

                          Worlds: Tabs for Programming

                          Via Lambda the Ultimate a pointer to a paper by Alessandro Warth and Alan Kay (PDF) called "Worlds: Controlling the Scope of Side Effects". I didn't get as much out of reading the abstract as I did from the opening paragraphs of the intro: Suppose that, while browsing the web, you get to a page that has multiple links and it is not clear which one (if any) will lead to the information you're looking for. Maybe the desired information is just one or two clicks away, in which case it makes sense to click on a link, and
                          Continue reading...

                          Javascript Thunks

                          I love how Javascript libraries like JQuery require people to use thunks all over the place: $(document).ready(function() { $("#orderedlist li:last").hover(function() { $(this).addClass("green"); },function(){ $(this).removeClass("green"); }); }); The functions without parameters are called thunks and their purpose is to delay the evaluation of the code in argument positions, circumventing standard applicative order evaluation. Here's hoping that future languages--even future versions of Javascript--take this need into account and add real linguistic features for delayed evaluation. Oh wait--Lisp already does and it's only 50 years old.
                          Continue reading...

                          Parsing with Perl

                          The system we're building at Kynetx includes a domain specific language that uses rules to create JavaScript programs that get sent down to the browser. I've documented our decision to use a domain specific langauge and our choice of Perl in other posts. When I started this project, I was reading Mark Dominus' book Higher Order Perl and started using his HOP parser to play around with. One thing led to another an before you know it I had a full blown language parser in HOP without giving much thought as to whether or not I'd made the right
                          Continue reading...

                          Anti-Perl Social Engineering

                          Dave Cross has a piece on why corporations hate Perl. He's being a little hyperbolic (as he admits)--not everyone hates Perl, but he's right in noting that there is a backlash against it. He says: I was talking to people from one such company last night. The Powers That Be at this company have announced that Perl is no longer their language of choice for web systems and that over time (probably a lot of time) systems will be rewritten in a combination of Java and PHP. Management have started to refer to Perl-based systems as "legacy" and to
                          Continue reading...

                          Transactional Memory

                          We all know that Intel and AMD have punted. They can't keep building larger, faster chips for a variety of technical and economic reasons, so they have started placing multiple cores on a single chip. This, in theory, maintains the overall processing power and is easier to build. There's just one catch: it's much harder to program because to make use of that power, you have to program concurrently. Don't get me wrong. I'm not complaining. Microprocessor engineers have saved programmers from the hassles of concurrency for years. That's as it should be: get it right once at the
                          Continue reading...

                          Tyler Close: Using Promises to Orchestrate Web Interactions

                          Tyler Close answers questions after his talk(click to enlarge) Tyler Close of Waterken fame presented a way of using promises to produce succinct JavaScript (and Java) code for doing multiple asynchronous requests with a Web server. The idea of promises in asynchronous systems was developed by Barbara Liskov in the late 80's. Tyler has a tutorial online. I also found this description from Brian Lothar of Web calculus which discusses promises in that context. Very interesting stuff. I think this was my favorite presentation of WWW2008.
                          Continue reading...

                          Can Your Programming Language Do MapReduce?

                          Joel Spolsky has a great, understandable description of what MapReduce is and why you might care. He also speaks to the benefit of learning functional programming, even if your first job interviewer isn't going to ask you "Have you even programmed in {Lisp, Scheme, Haskell}?" We're all going to care a lot more about things like MapReduce as the number of cores on a chip goes up exponentially.
                          Continue reading...

                          John McCarthy on the Elephant Programming Language

                          John McCarthy(click to enlarge) He wasn't on the program, but this morning's keynote was given by Professor John McCarthy--the inventor of LISP and coiner of the term "artificial intelligence." This morning, he's talking about Elephant 2000, a programming language designed for writing programs that interact with people. One of the things he points out that I find interesting is the idea that the compiler should generate required data structures without the user having to specify them. I'm not sure how that works from his explanation, but I'm certain that if we want languages that admit more parallelism, this is
                          Continue reading...

                          Fran Allen: Compilers and Parallel Computing Systems

                          Fran Allen delivers Organick Lecture(click to enlarge) Fran Allen was the Turing Award winner for 2006. This afternoon she's giving the University of Utah's Organick Memorial Lecture. I've reported on some of these in the past few years: Jim Gray on Distributed Computing Economics Vint Cerf on Internet Challenges Alan Kay: Is Computer Science an Oxymoron? Alan Kay: The 100 Dollar Laptop and Powerful Ideas Jeannette Wing on Computational Thinking I try to come every year. I find it's something I'm inspired by each time. The grand goal of high performance computers right now is a 1 petaflop machine.
                          Continue reading...

                          On Static Types and Language Choice

                          I caught a little flack in response to my post calling attention to Steve Yegge's recent essay "Portrait of a Noob." In particular Levi thought I was out of line for endorsing something so inflammatory: "People who approach programming differently than I do are insecure n00bs" That's a great attitude for a professor to endorse in a public forum. Steve's rant is nothing more than hot air attempting to justify his personal preferences at the expense of others. It makes you feel good because his preferences are the same as yours. The fact remains, however, that there's no real
                          Continue reading...

                          The IO Programming Language

                          One of my students, Duane Johnson, asked me this morning if I'd heard of the IO programming language. I hadn't. Looking around, it looks like a fun little language. IO is a "pure" object oriented programming language with a simple syntax. IO is a prototype-based OO language. Consequently, Javascript programmers will find the sample code pretty easy to follow. IO's reflective capabilities are very impressive. IO isn't, as far as I can tell, ready for your next programming project--yet. It's still experimental. Still, it's good to see new languages spring up. There are good ideas to be had and
                          Continue reading...

                          Is Intuitive Always Good?

                          Here's a good, short artcile from Raganwald on the trade-off between intuitiveness and programming languagge expressiveness. Most of the article is a few quotes. The meat is at the bottom. Is Ruby's for loop an improvement over Java? By how much? Ruby's big win over Java in that regard is the ease with which you can use Enumerable's collect, select, detect, and inject methods. Which, of course, are not familiar to the programmer with a grounding in for loops. They require study to understand. But once understood, they make code easier to read thereafter. When you're building a new
                          Continue reading...


                          Here is proof positive that the utility of a domain specific language depends on the domain.
                          Continue reading...

                          Java Desktop Developments

                          This week's show on the Technometria podcast is an interview with Chet Hasse. Chet works for Sun Microsystems in the Java Desktop group. We talk about upcoming features in the Java desktop and Sun's applet strategy. Chet's new book Filthy Rich Clients: Developing Animated and Graphical Effects for Desktop Java Applications will be out in August. I'm sure this will be a great book for anyone interested in developing Java clients. The best GUI people I know also have some genuine artistic abilities. If you check out Chet's blog you'll see he fits the bill.
                          Continue reading...

                          Fast, Interpreted XML Parsing

                          I'm in a presentation on a paper called A High-Performance Interpretive Approach to Schema-Directed Parsing (here's the PDF for the paper). Last year these authors presented a fast, validating XML parser (called Screamer) that outperforms Xerces (validating) and Expat (non-validating) by considerable amounts. The problem was that it compiled a custom parser for each XML schema. The fact that it required compiling code made it undeployable with products like DB2 (they work for IBM). This paper presents an interpreted version of Screamer, called iScreamer that is still fast, but doesn't require using a compiler. Instead it produces a parse
                          Continue reading...

                          Alan Kay's Early History of Smalltalk

                          If you're interested in programming language design, this history of Smalltalk by Alan Kay from the 1993 HOPL conference is worth reading. That was the second HOPL conference. The third is happening June 9-10 in San Diego. I'd go if it wasn't on a weekend. I refuse to do weekend conferences. Still, it looks like a great program.
                          Continue reading...

                          John Backus Dies

                          John Backus, the inventor of FORTRAN, BNF, and winner of the 1977 Turing Award (read his lecture) has passed away at 82. I tell my CS330 students about Backus and the development of FORTRAN every semester when we discuss BNF (he's the "B" in BNF). As I said when Ralph Griswold died a few months ago, Computer Science has always been a discipline where the founders were still around. That's changing.
                          Continue reading...

                          Composition as a Programming Activity

                          When I started programming, you had four choices on the IBM 370 system that the University of Idaho made available to students: Cobol, Fortran, Basic, and APL. I learned Fortran and Basic, avoided Cobol because it was for "business", and looked on APL with wide-eyed wonder. "Someday," I thought, "when I'm all grown up, I'll learn APL." Well, of course, that day never came (I never grew up and I never learned APL). I'd kind of thought APL was dead--after all, you don't hear about it much. People refer, jokingly, to APL as a "write-only" language because it's very
                          Continue reading...

                          Haskell vs. Java Smackdown

                          Defmacro.org has a small example of Haskell's expressive power and the same code written in Java. Both take five lines of code to "[go] through a parse tree of Haskell source code, locates every reference to an identifier that ends with 'Widget', puts it on a list, and removes duplicates so every identifier is represented in the list only once." Impressive. I believe that Haskell code is a bit more general and defmacro.org argues that it's more maintainable. You be the judge.
                          Continue reading...


                                                  Second-hand housing



                                                  Real estate

                                                  Mobile Games


                                                  Buy a car