Slashdot Mirror

http://www.acooke.org/andrew/electronics/spice.html- Spice and GEDA tutorial

http://members.dslextreme.com/users/billw/gsch2pcb/tutorial.html-Bill Wilson's tutorial on using gEDA/gaf, gsch2pcb, and PCB

Ugg! These tutorials are completely ancient. I have removed them. Thanks.

The official documentation for the gEDA project can be found here: Official Documentation

Seriously, if you want folks to use gEDA, release a beginner's guide showing how to make something simple, like a fm transmitter or lm317 board, and how to successfully prepare it for sending off to some place like batchPCB.

How about these documents:

• gsch2pcb_tutorial
• gschem_warmup
• transistor_guide
• Getting started with PCB
• ngspice and gschem
• tragesym tutorial
• Circuit Design on Your Linux Box Using gEDA

There is lots of documentation available for using the gEDA suite of tools and the geda-user mailing list is very friendly to all levels of users. I could probably dig up a few more tutorials if the above isn't enough. :)

I've also added a bunch of new free/open source hardware projects to the gEDA links page. There are some really awesome projects listed there that do not use proprietary tools.

http://www.acooke.org/andrew/electronics/spice.html- Spice and GEDA tutorial

http://members.dslextreme.com/users/billw/gsch2pcb/tutorial.html-Bill Wilson's tutorial on using gEDA/gaf, gsch2pcb, and PCB

As for the images, it allows us to take her work and recreate it. Now, if having to look at images and actually recreate a schematic is a problem, then I'd suggest recreate the schematics, pcb's, and release them in whatever format you want. She's released under an opensource license, so there shouldn't be a problem. Heck, I imagine she'd even let you submit them to her github for download.

Seriously, if you want folks to use gEDA, release a beginner's guide showing how to make something simple, like a fm transmitter or lm317 board, and how to successfully prepare it for sending off to some place like batchPCB.

I guess I am probably too late to be noticed, but for what it's worth I did exactly this. My notes are here - http://www.acooke.org/cute/SystemRefa0.html

In short: it works just fine, and sits (moderately quietly) in the corner, doing its thing. However, the processor is not really fast enough for desktop, so installing and getting everything working was a little frustrating. Also, that chip doesn't have automatic throttling support in Linux so I have a bit of a hack (see link). And the original fan was small and noisy, so I replaced it with a 120mm one.

My electricity bill dropped by about 1/3 since my main machine, which I use during the day for development work, is off for over half the time.

No really exciting differences, but the text without Slashdot's edits (which removed links, sub-headings and a paragraph that explained what I was doing) can be found here.

The following is taken from Andrew Cooke's excellent write-up of issues like this...

http://www.acooke.org/andrew/writing/lang.html#sec -staticdynamic

Static and Dynamic Typing

Types can be static or dynamic. Languages like Lisp or Python have many different types, but when you look at a piece of code there is nothing that forces a variables to "be" (or to "point to") a piece of data of a particular type. In other languages, like ML or Eiffel, a certain variable will always be connected with a value of a certain, fixed type. The first group of languages (where the type of everything is unknown when the program is compiled) has dynamic types, the second group has static types.

Dynamic types are good because the program source can be more flexible and compact (which might be particularly useful for prototyping a system, for example). Static types are good because they allow certain errors in programs to be detected earlier (a compiler for a statically typed language may also be able to make extra optimisations using the extra information available, but this depends on details of particular languages and compilers).

My own view is that at computing projects become larger, static typing becomes more important. I would not like to work on a project with many other programmers using a dynamically typed language, and I choose to use dynamically typed languages, usually, when doing projects of my own.

In some languages (e.g. ML) the interpreter or compiler can often work out the type associated with a variable by itself, which saves the programmer a lot of effort.
Strong and Weak Typing

Types can be weak or strong. The languages mentioned above are all strongly typed, which means that at any point in the program, when it is running, the type of a particular chunk of data is known.

Since a dynamically typed language does not have complete type information at compile time it must, if it strongly typed, keep track of the type of different values as it runs. Typically values are boxed together with information about their type - value and type are then passed around the program together.

It might seem that a strong, statically typed language would not need to do this and so could save some memory (as type information is available when the program is compiled). In practice, however, I believe that they still do so - possibly because of polymorphism (see below).

Unlike the languages mentioned so far, C has weak typing - some variables can point to different types of data, or even random areas of memory, and the program cannot tell what type of object is being referred to. Depending on the context within the program, the variable is assumed to point to some particular type, but it is quite possible - and a common source of confusing bugs - for this assumption to be incorrect (some type checking is done by a C compiler, but not as much as in a language designed to have rigorous compile time checking, like those described as statically typed above).

Java is strongly, but not statically, typed - classes can be converted (cast) and, if the types are not compatible (related through inheritance - see below), a run time error will occur. Apart from this (significant) exception the Java type system can be considered static - one description is "compromised strong static typing".

When strong static typing is enforced (even if only partially, as in Java) it can be difficult to write generic algorithms - functions that can act on a range of different types. Polymorphism allows "any" to be included in the type system. For example, the types of a list of items are unimportant if we only want to know the length of the list, so in ML a function can have a type that indicates that it takes lists of "any" type and returns an integer.

Another solution to the problem of over-restrictive types is to use inheritance from OOP (see below) to group data together. Yet another approach, used in C++, is templates - a way of describing generic routines which are then automatically specialised for particular data types (generic programming and parameterised classes).

it depends very much on the job, for two reasons. first, you probably aren't going to be writing code all the time. you might spend a lot of time doing design work, requirements gathering, use cases, yadda yadda, or testing, or just sitting in meetings. second, work loads vary by huge amounts, depending on the company, position, etc.

my previous job ended up with 6 day weeks, working over 12 hours a day (i would guess, on average - at times we were there for 24 hours or more). most of that was writing code (with no design, etc etc). no way did i write code in my "spare time" then (and, even when i left, after having had a minor breakdown, for months i had no desire to program).

live and learn - my next (current job) i negotiated as shift working, with longish hours for 8 days, then 6 off. on average, i work average hours, but with (1) less room to work extra hours and (2) lots of time between shifts for my own projects. the employer cares more about design/process and it also pays more than twice as much (but that's due to rather odd circumstances - i live in s. america).

so, in the end, it comes down to what you make of it. you can get sunk into a project (like i was) where you're "responsible for saving everyone's jobs" (the world didn't end when i left, though), and it can ruin your life. or you can take a bit more control and have plenty of time (and energy) left for what you want to do.

(my current project is a little programming language, a bit like forth).

A solution in Malbolge would be really really amazing. No-one has shown that it is possible to do loops in Malbolge yet; and a program with that much output would be really hard to make.

Someone did finally come up with a "Hello World" in Malbolge! Well, almost. He managed to make a "HEllO WORld" program by writing a genetic algorithm that took a few hours to find the program.

This is the source code:

See http://www.acooke.org/andrew/writing/malbolge.html .

Apologies if self-linking in a thread like this is bad taste, but the post above mentions Dijkstras "A Discipline of Computer Programming". If anyone reads that book and is curious about the programs, they may be interested in an interpreter for the language that was used - http://www.acooke.org/jara/egg

I should add a quote from that book: None of the programs in this monograph, needless to say, has been tested on a machine. (and, of course, all the ones I tested worked)

Did you even read the article. I'll challenge you to find languages with much more different syntax from C/Perl than Befunge-98 and Brainfuck!

Malbolge. See these notes on writing hello, world in malbolge:

this malbolge program generates:

HEllO WORld

it's not perfect - i ignored case to make the problem simpler (completion left as an exercise for the reader - it should be possible).

when i finally got a decent algorithm worked out (i've been playing around with this for the best part of a month - see below), it took a few hours to generate the program on a 500mhz nt box with 96mb memory (the code was written in lisp - i started with clisp on suse linux and then changed to corman lisp on nt) (more numbers here).

incidentally, i've come to hate malbolge.