PSoC or FPGA?

On a sunny day (Tue, 22 Mar 2011 20:01:43 +0000 (UTC)) it happened Warren wrote in :

Better a sane minority in the mad house.

Not sure that analogy is the right one, how about this: Using a debugger is like spell checking by checking the font of each character, not only does it not help, as fonts are computer generated, it has no bearing on the spelling either. :-)

Jan Panteltje expounded in news:imcaqq$58m$ snipped-for-privacy@news.albasani.net:

..

That's the usual statement for inmates _in_ an insane asylum.

They believe they are the only sane ones and that its everyone else that is not.

You're saying debuggers don't help, which is simply not the case. It either suggests that you don't know how to use them or you've avoided them for so long that you don't know what they're capable of.

A debugger saves an enormous amount of time. Who wouldn't want to leverage that? I'll bet your employer would.

Some poor developers avoid learning gdb (for example) simply because they didn't want to take the effort to learn how to use it. It isn't difficult but some folks are lazy or lousy at self education. But that's a problem with the developer-- not the tool.

With the quality of the debuggers generally today, there is no reason not to use them. I for one, would not pay a developer to avoid debuggers so that they can spend time cooking up personalized macros and manually coding printf's all over the place. That's a poor use of a developer's time.

Macros BTW, are completely useless in a language like Ada, which I've been using for AVR stuff. Ada shortcuts software development because it encourages software _engineering_ that is often lacking in C and derivatives. Ada is very fussy about what gets compiled which saves debugging time (but I realize this is a language religious thing and that sometimes the language is dictated). Finally, any code added for debugging purposes clutters the code, which is bad. A debugger makes most of that completely unnecessary. One compiler option is all that it costs.

But if you don't want to use a debugger, then that is your own choice. One can only lead the horse to water.

But saying that debuggers are not useful is simply not generally accepted. There is a good reason for that!

Warren

On a sunny day (Wed, 23 Mar 2011 13:58:26 +0000 (UTC)) it happened Warren wrote in :

This world is one, just depends on your standard of 'sanity'.

The only case where a debugger may help is if you want to know why a BINARY of somebody else's code craches, when you have no source code. Not that it helps much to fix it if you know it is accessing an illegal address. If you have the source, as you SHOULD, look at the code. A few simple printf() statements will tell you all you want to know. I have been through piles of other man's source code, used parts of it, C reads like a novel to me, no matter what style it is written in.

I have to admit I have lost the capability of walking on my hands, actually never was good at it. To be honest I never tried very hard. All your insults show how incredibly unexperienced you must be with walking on your feet. For us who walk on those, you, on your hands, is amusing, but not something I would recommend to anyone for 'larger projects' like a trip to the next city :-)

Not using it saves all the time spend with a debugger.

You are too lazy and too stupid and too stubborn to take a good academic advice. Kids stuff.

Quality of debugger has nothing to do with it. If you want to shoot yourself in the head a good quality gun does not help save your life.

I rarely use macros, the printf() at the start of functions is just a few lines, if your typing skills are that bad that you cannot put those out in about 8 seconds each, then use your hours f*cking about with your [de]bugger.

Well that says it all, an other victim of ADA. It so happened I threw my ADA book in the garbage a few weeks ago, after not using it since 1989 or so. What the world has come to, what a bunch of crap. Maybe you work for the US DOD who once required ADA, but for real critical systems allowed 'other' languages (they had to), ADA would explain why they keep losing wars.

C has no derivate[1], is close to the hardware, and requires you to know what you are doing. ADA forces you into some insane form, that actually does not even prevent you from making basic mistakes, else you would not need your bugger at all.

[1] C++ is no language, it is a speech disability, a crime against humanity.

The word is 'sucks'.

Yeah, these days they instead spend time cooking up macros and plug-ins for the debugger so that it can "sanely" display various objects or structures. :-)

The other thing is that there really is a very broad range of programmer skill sets/proficiencies out there: My opinion is that, while all programmers make mistakes, the kind of bugs that very strong typing and other rigors that Ada imposes tend to prevent errors that a *certain subset* of programmers don't make anyway -- or at least only make on an incredibly rare occasion --, and instead *for them* it just decreases their average productivity a bit.

Overall it is your programmer's productivity that counts, as measured by, "how long did it take them to get this chunk of code to work in a bug-free manner?" -- regardless of what tools they choose (or are made) to use. My opinion is that software development is one of the few fields where the answer to this question varies far more than in many other fields; a 5:1 ratio is readily seen -- yet hiring the most productive programmers doesn't cost nearly

5x what hiring the least productive ones does.

My recollection is that Steve Wozniak wrote out all of the Apple I's BASIC in assembly language and then manually "assembled" it, still on paper, into op-codes. He did all of his debugging "on paper," and the first time he entered it into the actual CPU... it worked.

Many people couldn't pull off that feat with Ada, C++, Python or any other language out there. :-)

On the other hand... Woz and one other guy were off trying to finish DOS 1.0 before some trade show (probably Comdex), hopped onto a plane the day before, figuring that they'd had it done in a couple of hours after they arrived at their hotel. Instead they were programming all through the night, finishing just a couple of hours before the show was set to open... at which point Woz figured he'd make "one last test" of the read/write sector routines before getting some shuteye... and inadvertently did so using the disc he was using to store DOS itself rather than their test disc, thereby wiping out all the progress they'd make that past night.

Everyone's human? :-)

(The story then continues that he did go to sleep, woke up that afternoon, and fixed everything still that same day -- having remembered most of the details of what had been done --, so they only lost the one opening day of the trade show without a demonstrably working DOS. Excellent recovery there, at least.)

---Joel

Joel Koltner expounded in news:pfoip.771840$ snipped-for-privacy@en-nntp-15.dc.easynews.com:

No doubt.

The comp.lang.ada forum would disagree with that on the whole, but that is another discussion I don't want to pursue here. They'll suggest that there is more to it than that (and I agree).

Agreed generally.

I've also hand assembled lots of code in the '70s. It's no big deal, just extra effort. When you have no choice, it can be done. Now that is rarely needed, with the tools available today.

Computer time was considered more expensive than programmer time in those days (speaking generally). Things are considerably different today. It makes no sense to do a time consuming desk check when testing it can do it in an instant. Yes, there are exceptions to that, depending upon the nature of the project (like critical flight control systems).

Ada is used whenever there are safety critical and life threatening situations. There is a reason for that. If you hang out on comp.lang.ada, you'll see that there are tools that build upon Ada and take the checking to an even more rigid extreme. But that is moving OT..

Warren

Jan Panteltje expounded in news:imd33m$s4n$ snipped-for-privacy@news.albasani.net:

Hogwash. It can be used in this situation, but it is not the "only" situation where it is useful.

And to wait for a rebuild a huge system to compile that added printf statement, which might take you 30 minutes, this is terrible waste of time. For small projects, you can tolerate all kinds of il-advised development practices.

But a huge project or not, needs no recompiles, no relinking or running of makefiles. You just invoke it with the debugger, or heaven forbid, just attach to an already running program and take control.

Your skill level is academic. It needs to read well for others on your team.

And, if your code is being reviewed, as it happens in safety critical systems, that "added code" (if it stays in) now needs to be verified that it is not going to become a flight critical error. Less is more in critical software.

So you've never really tried to use it but are telling everyone to trust you that a debugger is worthless?

Insults?

I'm trying to understand how someone can dis a very useful tool in the current environment. Debuggers have never been better, but you say they are useless based upon (IIRC) some article in the early '80s.

It's your choice man.

Bad antiquated advice from decades ago hardly applies to the tools we have today. That might have been good advice for some big iron environments of the time. But I even recall using C/PM and DOS debuggers, that were still plenty useful on the microcomputer front.

But I leave you to your own fate.

A gun is very useful in the hands of a hungry hunter. If you shoot yourself in the foot, then that says a lot about you as a hunter.

It ain't the gun's fault.

You've left out the make process, which can be huge in a large system.

But clearly you don't know about debuggers.

No, it is Ada (not American Dental Association or some other acronym).

..

Actually, as I understand it, each project still gets reviewed before they relax the Ada requirement. I also understand that a lot of contracting firms still use Ada due to the cost savings in the testing and maintenance. Others however, are getting my billable hours by using other languages.

You've clearly never mastered Ada and has changed a lot since your '89 text. Ada is not your grandfather's Ada-83 that you remember. It has undergone a major revision in '95, and 2005. It is now headed for a new revision of the standard in 2012. As a standard, Ada is one of the best "well defined" standards.

It's not my favourite, but like C, it has its place in the world.

A clearly uninformed opinion.

Warren

Sorry but that is nonsense. A debugger is very usefull to see if the code is actually doing what it is supposed to do. Not just verifying the output is (accidentally) right. In case of an exception it will lead you right to the offending function. If you're lucky you'll get a stack trace as well.

Output from print statements are usefull when the program is running at a client and the client is able to capture them in a log file. Print statements also help debugging real-time processes which cannot be stepped.

--
Failure does not prove something is impossible, failure simply
indicates you are not using the right tools...
nico@nctdevpuntnl (punt=.)
--------------------------------------------------------------

You'll have to read the specs or reference manual to get noise and bandwidth information. I don't remember them, but, in the PSoC1, not all that great.

I don't know what you mean by 'brick', but, yes, the input pins are selectable, the output pins are selectable, the type of analog (continuous analog or switched cap) is selectable. The switched cap modules make the ADs and DACs, filters, modulators, demodulators, etc. The continuous analog makes amplifiers, instrumentation amps, and comparators. Internally, you can route signals between blocks for various uses.

Bottom of the line (PSoC1) data sheet:

PSoC3 (8051 core): PSoC5 (ARM core):

If you want more than the data sheets, the Technical Reference Manuals (TRM) are available.

If I can help get more info for you, let me know.

Cheers, John

Well, there you go! Have fun!

_With_ my(?) simulators? Someone has to do the shit work. Even DimBulb is employed, evidently.

I wish Ada where available for ARM. I really love to try it for a microcontroller project. If I'm right its like programming with the cruise control on.

If you concentrate on driving a car, you can keep your speed constant. But why bother if you can have cruise control? Not having to think about pitfalls is much more efficient than knowing how to avoid them.

I know that kind of code. Try to add something new later.

--
Failure does not prove something is impossible, failure simply
indicates you are not using the right tools...
nico@nctdevpuntnl (punt=.)
--------------------------------------------------------------

Programmers never make buffer overrun errors? Nah, Windows has none of them...

It's also hard to tell the difference.

People can *read* S/370 core dumps. Manual assembly on many antique processors isn't difficult. Not all processors are the mess that is x86.

Not sure how to parse that challenge. Manual assembly of a HLL? ;-)

Especially the night before a trade show. ;-)

Why do you think it's not? GNU compiler chain has a full blown Ada95 front-end and an ARM back-end.

--
Muzaffer Kal

DSPIA INC.
ASIC/FPGA Design Services

http://www.dspia.com

Ada is available for GCC. Looks like some people have problems building the libraries for it as a cross compiler, but arm-rtems should work:

But I didn't try it.

--
Frank Buss, http://www.frank-buss.de
piano and more: http://www.youtube.com/user/frankbuss

The last time I checked there was no 'real' Ada for ARM. Ada is available for most platforms GCC supports except ARM. It has something to do with the Ada runtime libraries and ARM changing their ABI too often.

--
Failure does not prove something is impossible, failure simply
indicates you are not using the right tools...
nico@nctdevpuntnl (punt=.)
--------------------------------------------------------------

Nico Coesel expounded in news: snipped-for-privacy@news.kpnplanet.nl:

Gnat Pro seems to support it, though I don't know about cost etc.:

n56cCFYi8KgodLxPXaQ

If you google "gnat arm" you might find instructions to cross compile it for free, though it is probably a difficult build from what I've seen.

If you want to just give Ada a spin, perhaps the easiest thing to do (for Windows users) is to install Cygwin and have the gcc-ada compiler installed.

Ada Core also has native windows IDE environment (if you like that sort of thing) called GPS, which is free for download and use.

Warren

Why, were you teaching them COBOL or Ada?

Just kidding. :-) (...running for cover from all the COBOL and Ada proponents...)

I take it the language was something like C or Java or BASIC?

I'm rather grateful that they taught us how to convert to and from base 5 back in elementary school -- made it that much easier when I started learning useful bases like 2 and 16!

x86 assembler, but the language was irrelevant. They couldn't do it themselves, much less write pseudo-code to do it.

We were doing arithmetic and converting between bases (directly, not through base-10) in every base up to 32 (characters got tough after that) when we were in fifth and sixth grades. Jr. High was a total waste, though.

A certain percentage of them might have been able to pull it off in a HLL if not assembly (of the ones who could at least create pseudo-code).

That's cool... in retrospect, it does seem a little odd that in my class it was just base 5 rather than covering arbitrary bases.

That's where I was first taught algebra, which was of course quite useful... although I do also recall spending far more time than seemed warranted on "directional proportional to" and "inversely proportional to"-type problems. (But then again, in our "social studies" class in middle school, there was a section on how to use a map, and I had a hard time imagining how it was that anybody didn't already know that -- staring at the map was one of the diversions of last resort on long car trips, after all. :-) )