"As noted in other posts, I am currently using Subversion for source code control, with TortoiseSVN as the “GUI” client. Recently I’ve been having big performance problems on my machine, particularly with Windows Explorer. Getting rid of most of the network drives that I’ve added helped quite a bit, and then I turned my attention to TortoiseSVN.
Our SVN repository is located in New York, whilst we are in London, and the network between the two sites is not great. For example, when we moved offices our new network was only 10mbit/s rather than 100mbit/s. Gigabit? Tish and pshaw! Combined with the fact that our project is 436Mb means that SVN can sometimes crawl."
Friday, December 29, 2006
Saturday, December 09, 2006
Philip is a researcher at Avaya Labs (a spinoff of Lucent Technologies). Prior to joining Avaya, he was a researcher at Bell Laboratories. His e-mail address is email@example.com.
As the 19th century drew to a close, logicians formalized an ideal notion of proof. They were driven by nothing other than an abiding interest in truth, and their proofs were as ethereal as the mind of God. Yet within decades, these mathematical abstractions were realized by the hand of man, in the digital stored-program computer. How it came to be recognized that proofs and programs are the same thing is a story that spans a century. The story ends with a new principle that is guiding the design of a new generation of programming languages, including mobile code for the Internet.
Modern logic began with Gottlob Frege in the late 1870s. Two aspects of Frege's work reached a culmination a half century later, in Gerhard Gentzen's natural deduction, which captured a notion of proof, and Alonzo Church's lambda calculus, which captured a notion of program, both first published in the early 1930s. As it turns out, there is a precise correspondence between Gentzen's proofs and Church's programs, but that was not uncovered until the late 1960s. As the 21st century begins, that correspondence sits as a cornerstone of modern programming language design.
For my money, Gentzen's natural deduction and Church's lambda calculus are on a par with Einstein's relativity and Dirac's quantum physics for elegance and insight. This article gives a taste of these ideas; for more detailed information on these topics, go to http://www.ddj.com/ articles/2000/0013/0013toc.htm.
Saturday, December 02, 2006
Q. I'm not sure this is very "extreme" but I add records to my typed DataSet and am getting a d2p1 prefix on my attributes in addition to an xmlns:d2p1 declaration on the elements. This seems to be some default value. How can I specify a namespace to get MyNS:attribute instead of d2p1:attribute?
A. In the properties for the schema set the attributeFormDefault to unqualified.
Thursday, November 09, 2006
Der Gruß am Ende des Briefes ist wiederum individuell gestaltbar, wobei man jedoch zwei Dinge beachten sollte: die Floskel 'Hochachtungsvoll' ist genauso veraltet wie den letzten Satz in den Gruß zu ziehen.
Weitere Möglichkeiten für die Formulieren des Grußes:
* Mit freundlichen Grüßen
* Freundliche Grüße
* Mit freundlichem Gruß
* Mit besten Grüßen
* Mit herzlichen Grüßen
* Herzliche Grüße
* Mit besten Grüßen und Wünschen
* Mit herzlichen Grüßen und Wünschen
* Mit den besten Grüßen aus ...
* Freundliche Grüße nach ...
* Mit herzlichen Grüßen und den besten Wünschen
* Mit herzlichen Grüßen von Haus zu Haus
* Mit den besten Wünschen für ein schönes Wochenende
Positioniert wird der Gruß eine Zeile unter dem Text."
Thursday, November 02, 2006
I'd actually recommend learning Erlang before Haskell or OCaml, because it helps plug the gap between dynamically-typed multiple assignment (Ruby) and algebraic data types and pattern matching. I was hopelessly lost the first time I looked at Haskell, because it includes all sorts of syntactic sugar that aren't really necessary to understand pattern-matching or ADTs (n+k patterns, guards, @ patterns, : for cons, definitional syntax, etc). Stick Erlang in there, and you can think of it like this:"
Monday, October 30, 2006
The Concurrency and Coordination Runtime (CCR) is a lightweight port-based concurrency library for C# 2.0 developed by George Chrysanthakopoulos in the Advanced Strategies group at Microsoft. Here are some of our design constraints for the CCR:
* We want to support coordination programming constructs as a library rather than by modifying an existing language or inventing a new language. Eventually the best way to add concurrency constructs is through language level support. We believe that it may too early now to freeze the coordination patterns(including joins, choice, etc) into a language because we do not yet have enough experience of their use. For the purpose of experimentation a library based approach seems more suitable. The arbiter architecture described below also allows us to experiment with new constructs in an extensible, composable way.
* We wish to support port-based programming where message passing is used not just at the interface of the program to communicate with external entities but as a software engineering mechanism to help structure our programs. Our desire is to use message passing to help provide isolation between different components for reliability and parallelism.
* We wish to support scenarios in which there is a very large amount of message-passing (e.g. "
Saturday, October 28, 2006
If two loops interact via changing their mutual environment, this is called passive stigmergy, and may result in unstable, divergent behavior. (The tribesman and the air conditioner; or when one agent tries to fill a container while another tries to empty it.) Active stigmergy, on the other hand, is when one loop manages the other loop directly, by altering its input. It's the tribesman adjusting the thermostat; it's working with the system, not around it.
Future of software design? Lambda the Ultimate: "Future of software design?
It's been a while since I submitted a story...here is some food for thought!
What will programming look like in 20 years? Maybe it will be based on a 'definitive language' like the speculations of the article Convergence in language design: a case of lightning striking four times in the same place (FLOPS 2006). Such a language will have a layered structure and its handling of concurrency is important. (Whether it is dynamically or statically typed is of absolutely no importance, BTW.)
How will we program with such a language? Maybe we will program with feedback loops, as explained in Self management and the future of software design (FACS 06). This seems to be one way to handle complexity, the inevitability of software and hardware faults, and managing global behavior of a system. I am coordinating a new project, SELFMAN, that is looking at this.
Thursday, October 19, 2006
StringTemplate is a java template engine (with ports for C# and Python) for generating source code, web pages, emails, or any other formatted text output. StringTemplate is particularly good at multi-targeted code generators, multiple site skins, and internationalization/localization. It evolved over years of effort developing jGuru.com. StringTemplate also generates this website and powers the ANTLR v3 code generator. Its distinguishing characteristic is that it strictly enforces model-view separation unlike other engines. There are currently about 600 StringTemplate source downloads a month.
Terence Parr is the maniac behind both StringTemplate and ANTLR. He is a professor of computer science at the University of San Francisco. "
IKVM.NET is an implementation of Java for Mono and the Microsoft .NET Framework. It includes the following components:
* A Java Virtual Machine implemented in .NET
* A .NET implementation of the Java class libraries
* Tools that enable Java and .NET interoperability
Read more about what you can do with IKVM.NET."
Monday, October 09, 2006
Introduction to NLog - The Code Project - C# Programming: "Take a look at the Microsoft Enterprise Instrumentation Framework
NLog is a .NET library which enables you to add sophisticated tracing code to your application, delivering the functionality mentioned above and much, much more.
NLog lets you write rules which control the flow of diagnostic traces from their sources to targets, which could be:
* a file
* text console
* email message
* another machine on the network (using TCP/UDP)
* MSMQ-based message queue
* Event Log
* and others, described here
In addition, each tracing message can be augmented with pieces of contextual information, which will be sent with it to the target. The contextual information can include:
* current date and time (in various formats)
* log level
* source name
* stack trace/information about the method that emitted the tracing message
* values of environment variables
* information about exceptions
* machine, process, and thread names
* and many more, as described here"
Tuesday, September 26, 2006
Termite is an Erlang-like distributed programming system written in Scheme. It requires the latest version of Gambit-C.
Download Termite using darcs with the following command:
darcs get http://toute.ca/termite
You can also browse the repository here, or download a potentially out-of-date tarball.
Finally, there's a paper written about Termite.
Questions, comments and error reports should be sent to Guillaume Germain (guillaume.germain [at] gmail.com)."
Thursday, September 21, 2006
Wednesday, August 23, 2006
Windows PowerShell is a new command line shell and task-based scripting technology that provides comprehensive control and automation of system administration tasks. Windows PowerShell allows Windows administrators to be more productive by providing over 100 system administration utilities, consistent syntax, and improved navigation of common management data such as the registry or Windows Management Instrumentation (WMI). Windows PowerShell also includes a scripting language which enables comprehensive automation of Windows system administration tasks. The Windows PowerShell language is intuitive and supports your organization’s existing scripts and command line tool investments. Exchange Server 2007 and System Center Operations Manager 2007 will leverage Windows PowerShell to provide improved command line automation."
Scripting Tools and Utilities
If you want something done right, why not let someone else do it for you? All the tools you need to create great scripts are right here. If it’s not here, it doesn’t exist. Or it’s somewhere else, but you’re on your own there."
Monday, July 10, 2006
From Wikipedia, the free encyclopedia
Jump to: navigation, search
For multi-threaded programming, see Thread (computer science).
In computer science, the term threaded code refers to an implementation technique for programming languages that produces very compact code. Threading is a form of code consisting entirely of subroutine calls, written without the subroutine call instruction, and processed by an interpreter, which jumps to each successive subroutine in turn.
Threaded code is used in the Forth and early versions of the B programming languages, as well as many implementations of FORTRAN, BASIC, COBOL and other languages for small minicomputers.
The benefits of extremely compact code, in some cases, come at the expense of slower execution speed. However, in other cases there is a synergistic effect -- sometimes threaded code is smaller and faster than non-threaded code. In systems with virtual memory (where memory is simulated with a mechanical disk drive), threaded code may be hundreds of times faster than a less-compact design that does not fit in the available physical memory, because disk drives tend to be roughly a thousand times slower than random-access memory (RAM)."
Sunday, April 16, 2006
From Lambda the Ultimate:
E Thesis: Robust Composition
Mark S. Miller's PhD thesis on Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control is now online.
E rates as a (very) important language for anyone interested in ideas of messaging, distribution and security. The nice thing about a thesis (such as this one and Joe Armstrong's) is that it gives a nice historical account of the related work and influences.
When separately written programs are composed so that they may cooperate, they may instead destructively interfere in unanticipated ways. These hazards limit the scale and functionality of the software systems we can successfully compose. This dissertation presents a framework for enabling those interactions between components needed for the cooperation we intend, while minimizing the hazards of destructive interference.
Great progress on the composition problem has been made within the object paradigm, chiefly in the context of sequential, single-machine programming among benign components. We show how to extend this success to support robust composition of concurrent and potentially malicious components distributed over potentially malicious machines. We present E, a distributed, persistent, secure programming language, and CapDesk, a virus-safe desktop built in E, as embodiments of the techniques we explain.
And from Joe Armstrong SICS home page: "Programming reliable systems (Ph.D. thesis)
making reliable systems in the presence of software errors.
Here are some ideas on how to make reliable systems that function even in the presence of software errors. This thesis describes the thinking behind Erlang, Concurrency Oriented Programing, UBF and building reliable systems from communicating components."
Wednesday, February 15, 2006
Salamander is a .NET decompiler that converts executable files (.EXE or .DLL) from Intermediate Language (IL) binary format to high-level source codes, such as C#, managed C++, Visual Basic.NET, etc. For more than 8,000 classes that have been tested, Salamander always produces equivalent and recompilable codes that are remarkably close to the original source codes.
you can try it online here
Another very interesting decomplier is Ankarino, a very powerful command line tool which is provided as an open source utility, so you can get under the covers and see how it works.
give it a whirl here"
Thursday, February 09, 2006
Some great suggestions from this article!
"Debugging Asynchronous Applications?
Posted by Cliff on Wednesday February 08, @08:20PM
from the mind-your-breakpoints dept.
duncan bayne asks: 'I'm attempting to debug a complicated telephony application, written in C#, that's almost entirely event driven. This is the first time I've debugged a large asynchronous application that isn't a GUI, and I'm curious to know what advice the Slashdot crowd has to share - have you any recommended tools, best practices, or common pitfalls to avoid?'"
I'm not sure if you are 2.0 yet, but if you are, start by taking a look at VS2005. In the debug department, enhancements include better JIT debugging, stepping into XML/Web services from a client, and state-driven object inspection. Object Test Bench (OTB) is a simple object-level test utility. You create instances of your objects, invoke methods, and evaluate results... to shorten the task of coding, debugging and re-coding. I'm not sure about telephony specifically, but WSE/WS* SOAP layers can be hard to manuever through in a debugger, yet VS2005 does it quite nicely via WSDL.
One other suggestion... "event bus" apps like you describe are good candidates for capturing as much runtime data as possible, so make sure you adjust your build parameters and do as much of that as possible, especially in problem assemblies. Oh, and don't forget to build nUnits. Sounds like you're walking into some prewritten code, but the effort might be worthwhile.
Tuesday, February 07, 2006
A new release of Shriram Krishnamurthi's programming languages book is available."
Scheme, Haskell, Prolog. He implements a lot of this crap in the book.
Friday, February 03, 2006
On this site you'll find some quick links to several sites about .NET, ASP.NET, upcoming technologies etc as well as links to my own articles and other projects I'm participating in.
I hope you enjoy your visit on my site! Also check out my technical blog which is updated far more regularly than this website :-).
Author: Bart De Smet, MVP on Visual C#
Thursday, February 02, 2006
There was Microsoft's Intentional Programming which does something along the line of what you want though less ambitious. SCID is a similar thing that was thought up earlier.
By Derek Elkins at Thu, 01/26/2006 - 18:59 | login or register to post comments
SCID looks neat, thanks for the link! (Although, at least at first blush it reads like a hyper IDE vs. something which can transmogrify between horribly different languages.)
By raould at Thu, 01/26/2006 - 21:24 | login or register to post comments
Not automated but...
It can't really be automated at this point, but there are efforts being done for more language interoperability. .Net is one of the examples, and a lot of people are now reusing the JVM in order to be 'Java compatible'.
However for both of theses you need to target either an high level language (by generating Java or C# sources) or directly the VM bytecode (JVM or CLR). That's why I wrote NekoVM which defines an easy-to-target intermediate language and provide the VM and the libraries to run it.
It should greatly ease the language compiler implementation by providing a common runtime. And if you write a Neko -> Your language converter, you will be able to reverse the process, and translate other languages targeting Neko back into yours."
Thursday, January 26, 2006
I know there was C? topic before. But the discussion really had more to do with Xen (XML, DB integration) than the Polyphonic C# concurrency part. I'm an Erlang newbie myself, but I already can see that asynchronous communication is the common thread to both languages and this approach is going to be big - can be used from embedded system to biz process orchestration.
Looking at the Santa Claus sample, C? code seems to be quite compact and the syntax extension to C# is minimal. However process/thread creation is implicit, and it seems to be a little more difficult to reason. I would imagine a solution in Erlang clearer, but maybe longer.
Any thoughts/pointers on the pros and cons of different concurrency approaches? We really should have a 'great concurrency shootout'."
MochiKit has HUNDREDS of tests. We build real applications with this thing. So even though development can move fast, we make sure to get tests written. This also makes platform compatibility issues much easier to detect and resolve than the 'guess and check' style of quality assurance seen in some of the other libraries out there. It's not broken.
MochiKit can adapt to anything you throw at it. It makes no assumptions about how your code needs to act, and it has hooks (by way of the the adapter registries) that makes sure that you can define your own comparisons, programmer representations, iterators, or DOM node coercion for any object in any way you wish. We'll gladly serve you all the Kool-Aid you want, but we're not goi"
It is tempting to compare this to various documents trying to show 'how to add objects to Scheme/Haskell/etc.' The solutions are rather similar..."
Wednesday, January 25, 2006
Posted by ScuttleMonkey on Wednesday January 25, @08:56AM
from the focus-on-the-problem dept.
An anonymous reader writes 'Content management specialist Seth Gottlieb has written an easy to understand how-to on selecting an open source CMS. Gottlieb is also responsible for the whitepaper 'Content Management Problems and Open Source Solutions' which summarizes 15 open source projects and distinguishes between open source CMS and proprietary software selection.'"
Tuesday, January 24, 2006
(Reflections on a Mythic Beast Who's Quite Remarkable, at Least.)
I NEVER saw a Purple Cow;
I never hope to See One;
But I can Tell you, Anyhow,
I'd rather See than Be One. "
Monday, January 23, 2006
Thursday, January 19, 2006
The power and simplicity of GParted on a biz-card sized LiveCD.
The CD aims to be fast, small in size, and use minimal resources
to get that disk partitioned the way you want it. GParted LiveCD is based on Slackware Linux and uses Xfree86's Xvesa, the lightweight Fluxbox window manager, and the lastest 2.6 Linux Kernel.
Being up to date is important! GParted LiveCD will be updated along side the GParted source releases and have minor releases when bugs are fixed or new filesystem tools become available.
GParted LiveCD runs on most x86 machines with a PII or better and a Vesa 2.0 compatible video card."
Wednesday, January 18, 2006
I was involved in an eternal debate again. This time I was very much convinced that it was going to be an easy one as it is one of my favorite topic. DataSets Vs Custom Entities. I can already see few eyebrows raised. J I know most of the times the answer is ‘It depends”. The job was cut out for me as I had to defend an Architecture which was using Custom Entities as data carriers. I am glad that I had to defend custom entities as that’s my personal preference as well. I probably won’t go into the complete details of my defending points. Probably, I shall write another post which will include all the points to consider before deciding upon the right data carrier for any application."
Over the last few days, there has been one thought running in my head - 'All roads lead to Lisp'. I've tried to get it out of my head but like a tune from the radio, it has firmly lodged itself into my head and refuses to let go. Why this state? Call it a confluence of several items. In particular, these 3.
- Joel Spolsky goes off and writes one of his best articles ever called 'The Perils of Java Schools' which talks about the perils of not learning Lisp. As someone who has been playing catch-up with functional programming since I wasn't taught Lisp at college, I definitely agree. I forwarded that article to some senior folks internally - which in turn lead to some interesting conversations
- I've been working on a prototype of something at work - where I started off the usual imperative programming style. Realizing that this wasn't going to scale, I rewrote it in functional style making full use of C#'s anonymous delegates and iterators. When I had to make a major change, it was *so much* easier to add in extra functionality since I was just passing closures around.
- After 2 hectic work-filled weeks, I took advantage of a long weekend to curl up with a book which has been called the best book on programming ever - Peter Norvig's Paradigms of Artificial Intelligence Progra"
C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Tool Developers Guide\Samples\clisp"
Tuesday, January 17, 2006
L Sharp is free software distributed under the terms of the GNU General Public License. You can download the latest release from Sourceforge. You may also want to read Rob Blackwell's Web Log.
This documentation is a work in progress and is subject to change."
Monday, January 16, 2006
Tuesday, January 10, 2006
* Technical Overview
* First chapter of a book describing the system
* Back of an envelope summary (my first source)
From the examples in the chapter, I thought it looked surprisingly simple to use - comparable to adding contracts in DbC, for example. I guess the analysis requires a little more effort?"
The smartest thing to do would be to find a way to use one of the perfectly good markup languages that have been designed and debugged and have validators and authoring software and parsers and generators and all that other good stuff. Here’s a radical idea: don’t even think of making your own language until you’re sure that you can’t do the job using one of the Big Five: XHTML, DocBook, ODF, UBL, and Atom."
Originally seen at Tim Bray: Don’t Invent XML Languages on Lambda the Ultimate
Monday, January 09, 2006
AT&T Wireless: firstname.lastname@example.org
Sunday, January 08, 2006
" What is a Photograph? A photograph is life distilled and preserved for eternity. An expressive face, a fleeting moment in nature, an abstract shape- these are the fundamentals of photography. A photograph conveys, in a way no words can, a sense of the mystery and beauty of life, nature, and the achievements of mankind."
Friday, January 06, 2006
Martin Croxford, Praxis High Integrity Systems
Dr. Roderick Chapman, Praxis High Integrity Systems
High-integrity software systems are often so large that conventional development processes cannot get anywhere near achieving tolerable defect rates. This article presents an approach that has delivered software with very low defect rates cost-effectively. We describe the technical details of the approach and the results achieved, and discuss how to overcome barriers to adopting such best practice approaches. We conclude by observing that where such approaches are compatible and can be deployed in combination, we have the opportunity to realize the extremely low defect rates needed for high integrity software composed of many million lines of code."
This article refers to Communicating Sequential Processes (CSP), the Hoare invention.