Electronics advances.

[Ervin]

Incorrect, the reason for the failure is due to poor software programming/techniques.

Sometimes yes, but not always. You can use the latest methods and languages, but results still can be far from your expectations.

[HR Solutions]

Is this like a private conversation between yourself....it doesn't make much sense!

Lol ..... exactly, but who are we to say anything .... I must be honest I can see why he "has left/asked to leave" other forums.

[Justloadit]

Sometimes yes, but not always. You can use the latest methods and languages, but results still can be far from your expectations.

An interesting point to observe, the high level language compiler is written with another high level language, and this may influence nesting and how the program compiles, and then executes the program.
Some experiences required to change a number of commands on one line to multiple lines to make the compiler compile better.

[irneb]

An interesting point to observe, the high level language compiler is written with another high level language, and this may influence nesting and how the program compiles, and then executes the program.

That's usually the case. A compiler for a very minimalistic language is made using assembly. Then this is used to make a compiler for a more capable language. Sometimes this process is repeated until the final language has a compiler which produces optimal "enough" code.

Even in some cases the same language itself is used to make its own compiler - referred to as Bootstrapping. Actually that's the usual case these days. Previously it would have been more prevalent to see a compiler made using some low level language (even entirely in assembly). But seeing as a compiler isn't needed to run extremely optimally itself, it makes more sense to use a high level language to write it - thus the programmer spends more time on the algorithms of translating source code to binary code and adding extra optimizations (i.e. more focused on the compiler's results) instead of worrying about how fast the compiler itself runs and how much ram it uses.

The thing to remember is that a compiler is nothing else than a "translator". It changes source code from one language into another. The usual case (for what is known as ahead of time compilers) is to translate some "high" level language (e.g. C) into machine code (i.e. binary codes which the CPU "understands"). You could see it as changing from one language into a language which gets run by the CPU, same as something like Java which gets compiled to an intermediate language (JVM byte-code) which then gets interpreted (run as it's loaded) through the JVM which itself is a machine-code compiled program.

Some ahead of time compilers tend to optimize the results better than others. And it's still possible to use a disassembler to convert the binary results from such compiler into ASM files which you can tweak to achieve even better results (if you know what you're doing). The problem with this of late is that most of the CPUs these days have an assembly language designed for compilers, not humans - so chances are you'd be extremely hard pressed to surpass the optimizations a decent compiler achieves by manually tweaking the assembly.

Even with those intermediate language compilers you can also still tweak the intermediate language itself. E.g. you can use something like ILDasm to change the DLL file into IL source. Not to mention most of these types of environments have a JIT compiler built into their runtimes - which performs optimizations as and when it runs the intermediate code. Sometimes such could even outperform an ahead of time compiler, like optimizing due to runtime data content (which an ahead of time compiler would not have known about).

Concerning the situation of some "languages" causing slow downs - that's true in some cases, not all. Usually the biggest culprit of this is garbage collection - i.e. a language / virtual machine environment designed to "clean up" the memory without needing the programmer to concern himself with those issues. The usual problem is that the entire program gets halted while the garbage collector checks if previously allocated RAM is still used - this is a big problem in Java. This is usually the major reason VMs and JITs do not surpass ahead of time in speed and definitely not in memory usage - a rule of thumb is that to get the same speed from Java's JIT as you'd get from a compiled C++ program you need 3 to 10 times as much RAM.

[irneb]

The other reason, is that modern programmers have no clue how the hardware works, and simply program away to get something to market as soon as is possible, with out doing a thou rough check, and leave it to the user to find the bugs and report it to the programmer.

Too true!

The problem with some programmer who've only ever known some high level language (especially a normally interpreted / intermediate compiled language such as Java) is that they don't "know" what's going on behind the scenes. Thus they tend to not even realize what's going on behind the scenes - thus getting situations where they select the wrong data structures, or use the wrong parameter passing strategies, or use heap allocation in preference to stack, etc. The major issue with these high-level languages is that they tend to hide the actual memory allocation, in most cases to such an extent that these programmers have never even heard of stuff like pointers and cpu cache alignment.

I always advise a prospective programmer to at least also learn a low level language. At least C, but preferably ASM. Even better would be to learn some HDL to understand the internals of the CPU itself (i.e. how to design the logic gates to interpret the binary codes). This gives a very good understanding of why some decisions are better than others for certain circumstances. E.g. a multi-dimensional array may be iterated faster if you can get contiguous areas into the cpu cache, or using an array when you need to insert / remove from the head is not the best idea (instead use something like a linked list or better a circular array). Which to learn first I'm not too sure of - personally I like with starting with a high level, then once getting to a decent capability start something like C/ASM and once you've got the gist, go back to the high-level and try to see what you can do to make your previous programs "better".

[adrianh]

I had an interesting issue the other day. I've gotten very heavily in DCC model railway electronics. I can across a very nice open design using a ATMEL ATTINY2313. I got in contact with the developer and got the Eagle files and source. I made the board, got a decent AVR programmer, downloaded the latest version of AVR studio and compiled the code. No matter what I did I couldn't get the code to fit in the AVR. The compiler kept saying that the code uses 110% of available micro space. I spoke to the developer and he told me to download AVR Studio 4.9.X dated 2007 odd and try that. The old compiler used about 90% of the micro's space. I think that it is better to create various micro compilers than try to shove every single option into one compiler. The AVRs and PICs have so many variants with so many options that they are bound to overload functions and stuff lots of options into them bloating the code. For example, the fact that one processor can run in 5 oscillator configurations doesn't mean that all the code needs to be pulled in because the particular processor has 2 options.

I think that development environments like Arduino, though they are nice, quick and like Lego, give people a false sense of achievement. It allows people to fool themselves into the belief that they can develop mission critical systems by merely slapping a "shield" onto a dev-board.

[Brett Nortje]

Circuit design.

The process of circuit design can cover systems ranging from complex electronic systems all the way down to the individual transistors within an integrated circuit. For simple circuits the design process can often be done by one person without needing a planned or structured design process, but for more complex designs, teams of designers following a systematic approach with intelligently guided computer simulation are becoming increasingly common.

In integrated circuit design automation, the term "circuit design" often refers to the step of the design cycle which outputs the schematics of the integrated circuit. Typically this is the step between logic design and physical design.[1]

Formal circuit design usually involves the following stages:

sometimes, writing the requirement specification after liaising with the customer
writing a technical proposal to meet the requirements of the customer specification
synthesising on paper a schematic circuit diagram, an abstract electrical or electronic circuit that will meet the specifications
calculating the component values to meet the operating specifications under specified conditions
performing simulations to verify the correctness of the design
building a breadboard or other prototype version of the design and testing against specification
making any alterations to the circuit to achieve compliance
choosing a method of construction as well as all the parts and materials to be used
presenting component and layout information to draughtspersons, and layout and mechanical engineers, for prototype production
testing or type-testing a number of prototypes to ensure compliance with customer requirements
signing and approving the final manufacturing drawings
post-design services (obsolescence of components etc.)

This is the basics of circuit design, but, for now let us concentrate on the design of the circuit specifically;

The design process involves moving from the specification at the start, to a plan that contains all the information needed to be physically constructed at the end, this normally happens by passing through a number of stages, although in very simple circuit it may be done in a single step. [2] The process normally begins with the conversion of the specification into a block diagram of the various functions that the circuit must perform, at this stage the contents of each block are not considered, only what each block must do, this is sometimes referred to as a "black box" design. This approach allows the possibly very complicated task to be broken into smaller tasks which may either by tackled in sequence or divided amongst members of a design team.

Each block is then considered in more detail, still at an abstract stage, but with a lot more focus on the details of the electrical functions to be provided. At this or later stages it is common to require a large amount of research or mathematical modeling into what is and is not feasible to achieve.[3] The results of this research may be fed back into earlier stages of the design process, for example if it turns out one of the blocks cannot be designed within the parameters set for it, it may be necessary to alter other blocks instead. At this point it is also common to start considering both how to demonstrate that the design does meet the specifications, and how it is to be tested ( which can include self diagnostic tools ).[4]

Finally the individual circuit components are chosen to carry out each function in the overall design, at this stage the physical layout and electrical connections of each component are also decided, this layout commonly taking the form of artwork for the production of a printed circuit board or Integrated circuit. This stage is typically extremely time consuming because of the vast array of choices available. A practical constraint on the design at this stage is that of standardization, while a certain value of component may be calculated for use in some location in a circuit, if that value cannot be purchased from a supplier, then the problem has still not been solved. To avoid this a certain amount of 'catalog engineering' can be applied to solve the more mundane tasks within an overall design.

So, we could make more flexible circuits or blocks.

This can be done by making the blocks more versatile by using my 'echo' effect. this would be where the message is sent to the whole system and used only by those that are programmed to pick up the signal. of course, if the echo effect would trigger more responses or 'actions,' then we need to go through the thing slowly.

Now, we can make each block more multi functional by making it in 'layers,' where the wires are so thin they will be able to be stacked on top of each other inside the block, and send messages through the block to the things they need to go to.

But, if that is messy, we could start the whole electronics process over!

So, if you were to have a button or trigger, then a information conductor, then a mechanism to trigger - this is similar to engineering, yes? - then you could make the thing work. if it needs advanced functions, rather make the thing bigger than more complicated. tis reminds me of Voda Phone when they released their first cell phone, they had a very big thing. so, we have our basic thing, now to make it smaller!

If we were to use smaller 'bits' doing only one function, we would be where we are today with electronics! it is still quite simple, they just put all the triggers onto a motherboard type thing, or, circuit board.

Now, to make it smaller and better, we need to observe a better 'programming language' or 'bus.' to do that we could use two or three buses, yes? these could be layered on top of each other, as, there is room - open up your remote control and see how much space there is!

If we were to want to build more options into it, we would need to use symbolic systems, like the Chinese language to activate the various parts. there they have very complex symbols and things for words, but, it fits into a small space! this will let the one it means to trigger work through the likeness of the symbols.

[adrianh]

Why do you keep posting this rubbish that nobody bothers to read?

[pmbguy]

Why do you keep posting this rubbish that nobody bothers to read?

Well... I just did a quick check and it's definitely cocaine... lots of cocaine

[adrianh]

Well. if there was ever a reason for getting a good education then this guy proves it...you know the saying "getting the cat by the tail"....in this case it's more like "Getting the bull by the udders"

[HR Solutions]

Lol .......

[Brett Nortje]

Explaining how radios work to kids.

Radios work on signals from transmitters. these are tuned to the signal of the radio frequency, and, then they are sent out into the world over a limited distance. the transmission comes from the Morse code type signals, as, they are sounds that are sent out at a lower volume, then picked up and broadcast over the radio speaker. this means, that when the world was young, Morse code came before radio, because it was the building blocks of the radio technology.

So, you have your message or song, and then you send out things we find easy today to use, like tablets and game boys and things like that. but, when the world was young, they wanted to send a sound to something else. try to whisper and you will find that your tongue and throat moves around a little bit, but you hear it well, of course. you cannot hear anything that you do not feel, so speakers are there to connect the body of the transmission to the tongue of the radio broadcaster, hey?

Now, when the thing is on one side, and you want to get it to the other side, you need to make sounds that cannot be heard, or bits that are electrical and magnetic, like a magnet, and then they collect on the other end and then we can hear them. but, to get them magnetic, you need to have heat of some sort, to heat up the magnet, and then it sends out tiny 'parcels' of heat that are felt by a super sensitive 'nerve' on the other end. this 'nerve' feels the heat, and, the heat it feels makes a noise through electricity like we just went through.