Here's something to offset all the
So, is this heresy or an unfortunately ignored truth?
A Methodology for Generating Verified Combinatorial Circuits. Oleg Kiselyov, Kedar N.Swadi, Walid Taha.
This is the final version of a paper accepted for Embedded Software Conference 2004. The paper doesn't show any circuits but the straight-line C code should be implementable easily.
There is a significant difference from FFTW in that the authors don't do any intensional code analysis -- the generated code is black box and can't be processed nor manipulated any further. Moreover, the generated code can't even be compared by equality. Oleg tells me that the paper is somewhat obsolete: it says that they approach FFTW in the number of operations in the generated code. That is no longer true: the power-two FFT generated code has exactly the same number of floating-point operations as that in codelets of FFTW.
Abstract interpretation is used to fix several problems in the generated code. This makes some optimizations possible (e.g., avoiding code duplication).
Multi-stage programming fans, enjoy!
Booch's Rational User Conference presentation on software archeology is available online.
This is related to our previous discussions about reading code, mining code for patterns and about the history of programming languages and software systems.
Obviously, many of the issues mentioned in the presentation (e.g., SLOC counts) are programming language dependent. The major case study is Eclipse, which should make this interesting to IDEs buffs as well.
See here for more on Booch's work on documenting software architecture.
This project's goal is to provide integrated support for Aspect Orientated Programming in Oracle's JDeveloper IDE. Where possible we hope to make use of, and reuse code from, projects that have solved similar problems for other IDEs. The initial focus of the project is to integrate ADJT, the AspectJ design time environment, into JDeveloper.
It would be interesting to see whether projects such as this will help get AOP accepted by industry.
You knew it couldn't be far behind, right?
Defining and Using Generics in Visual Basic 2005 on MSDN has the details.
From time to time I like to return to the issue of database integration, only to once again remark that the difficulty in creating good database APIs (as opposed to simply embedding SQL) is the result of the poor programming facilities provided by most programming languages (e.g., no macros for syntax extension, no continuation or first class functions to handle control flow etc.).
Why return to this topic today? Jeremy Zawodny aruges on his blog that Database Abstraction Layers Must Die!
Along the way he says,
Adding another layer increases complexity, degrades performance, and generally doesn't really improve things.
Why do we need an abstraction layer anyway?
The author uses an argument I hear all the time: If you use a good abstraction layer, it'll be easy to move from $this_database to $other_database down the road.
Double ouch, but true enough. Databases are like women (can't live with them, can't live without), and getting rid of one can be as painful as divorce...
So what's the solution? Surprise, surprise: use a libary. But isn't that an abstraction layer? Of course it is.
What Jeremy advocates is plain old software engineering and design. Everyone should do it. I can't beleive anyone does anything else.
But wait. I just told you it's hard to build such a library, since programming languages makes the design of such libraries hard (e.g., should you use iterators, cursors or return record buffers? should your library database access routine be as flexible as a select statement?) So we design libaries that aren't very good, but hopefully are good enough.
And that's the question I put before you. We all know about coupling and cohesion. We all know about building software abstractions. Are our tools for building abstractions powerful enough for this basic and standard abstraction: the database access abstraction layer?
Sven-Olof NystrÃ¶m presented his Soft-typing system for Erlang at the 2003 ACM Erlang Workshop. I haven't tried it, but I thought it looked promising. His conclusions are thought-provoking too.
Zing is a new software model checking project at Microsoft Research.
Software model checking is hard, but it is still a promising line of research.
Tools are generally influenced by the type of languages they model. On top of that, I am sure software model checking is going to influence language design and implementation.
Light-Weight Instrumentation From Relational Queries Over Program Traces. Simon Goldsmith, Robert O'Callahan and Alex Aiken.
Neel mentioned this paper when I complained on LtU1 that I haven't seen something interesting enough to post for a while.
It is indeed an interesting, well written, paper.
The authors show the design of Program Trace Query Language (PTQL), a declarative language for querying program behaviour. The PTQL compiler can then be used to instrument a java bytecodes and insert the required data capture operations.
Quite a lot of effot went into making the instrumented code efficient enough to allow queries to be evaluated while the program is running.
Active forum topics
New forum topics