Author Topic: Lattice iCE40 Bitstream Reverse-Engineered  (Read 28942 times)

0 Members and 1 Guest are viewing this topic.

Offline Bassman59

  • Super Contributor
  • ***
  • Posts: 2501
  • Country: us
  • Yes, I do this for a living
Re: Lattice iCE40 Bitstream Reverse-Engineered
« Reply #75 on: June 05, 2015, 03:47:47 pm »
But I don't think an HDL is particularly hard.

HDLs are not at all hard if your background is in digital logic design.

Quote
At least in an HDL once you get the basic building blocks you can establish a solid fundamental understanding of how everything else is built, because it has to adhere to the basic principles of digital logic which is set in stone (0,1,x,z was a bit weird though)

0, 1, X, Z are not weird -- at its base, binary logic has only only two possible states (you can guess what they are). You need X to model contention or some other unknown state, and you need Z to model the high-Z driver (tri-state) condition.

Quote
whereas higher level paradigms in your standard programming languages are laced with syntactic sugar and magic that often make little sense.

They make perfect sense if you are versed in the language and its paradigms. At first glance, Objective-C looks "weird" to the K&R C programmer, but after spending some time understanding it, you'll see that it makes sense.

Quote
I don't think there are as many people who write an HDL or if there are it's not as represented as your [regular] software development.

I'm not sure whether you mean "who write an HDL" as a) Engineers who use an HDL to describe logic for implementation in an FPGA or ASIC (or for simulation and verification, which is necessary), or b) tools designers who write synthesis and simulation tools for those HDLs.

But in either case, there are a lot more people writing software for all of the various processors than there are people designing FPGAs or ASICs.
 

Offline Muxr

  • Super Contributor
  • ***
  • Posts: 1369
  • Country: us
Re: Lattice iCE40 Bitstream Reverse-Engineered
« Reply #76 on: June 05, 2015, 04:18:05 pm »
(0, 1, X, Z) was weird for me at first since my background is mainly software design. I mean there is nothing hard about the states, they make perfect sense, what wasn't as easy was remembering the logic operation outcomes for X,Z that aren't always obvious to me. You probably don't have issues with it since it's what you do on a daily basis. Not difficult though I agree, just a bit weird for someone with my background.

Objective-C was pretty straight forward for me, people who aren't used to managing memory probably get hung up on the reference counting, but I didn't have any issues with it.

What I was referring to is higher level patterns which might not be obvious for someone not familiar with the pattern, like the first time you come across inversion of control in a large project (it may not be so obvious), or the first time you use a functional language like F or Haskell. But mainly I am talking about things people do in languages like Perl or Ruby... Where the language itself can be introspected and modified to implement new language features, I mean in Ruby you can completely change how string behaves and I know libraries who do just that, this all can make things really hard to understand. You can change the entire language which is why DSLs are common in Ruby.

Or languages which pride themselves on having a lot of syntactic sugar.

For instance this is valid perl, and I know programmers who get a kick out of writing clever code nobody can understand:

Code: [Select]
''=~('(?{'.(']])@+}'^'-/@._]').'"'.('/<[*-_<+>?}{>]@}+@}]])@+}@<[*-_<+>?}{>]@^'^'`^=_^<]_[[]+[/,]_/]-/@._]/^=_^<]_[[]+[/,|').',$/})')It prints a message.

These features are what make Perl powerful, but it's also the reason why the code can be a nightmare to understand.
« Last Edit: June 05, 2015, 04:36:47 pm by Muxr »
 


Share me

Digg  Facebook  SlashDot  Delicious  Technorati  Twitter  Google  Yahoo
Smf