9 ms·
Fresh IDE
- ungzd 9y agoI don't know what are use cases for that. Nowadays, if you are coding in assembly, you are probably doing some kernel things, embedding asm in C/C++ (for SIMD or something like that and not because compilers generate bad code), embedded code for microcontrollers or retro computers (i.e. ZX Spectrum). But Visual Studio-like IDE for making x86 application software, with GUI editor seems weird.
- johnfound 9y agoI am using assembly language for all my programming tasks. And most of they are application programming (Fresh IDE itself and many closed source projects in my work) or even web programming (https://board.asm32.info https://board.asm32.info). That is why I needed a powerful IDE, suitable for rapid programming of relatively big projects (500Kloc or higher).
- osrec 9y agoThis is interesting. Do you not find the dev process significantly slower than using a higher level language?
- johnfound 9y agoAbout twice slower than in HLL, with code reusing of course. But the code is more reliable and the debugging process is much easier. After some short debugging stage, most of the projects runs for years without single bug report or other support issues. I am not talking about the significantly higher speed, lower memory footprint and better UX (especially the response time of the UI is really much faster). As a whole the advantages are more than disadvantages IMHO.
- zoul 9y agoInteresting. Are you sure the increase in code reliability goes down to the language and not your skills? It feels quite contrary to my experience that a lower-level language would be more reliable.
- johnfound 9y agoWell, I am pretty average programmer. Not the worst, not the best. The code reliability of assembly programs is better because programming algorithms in low level, the programmer controls every aspect of the execution. Notice, that excessive use of code generation macros will cancel this advantage. Another advantage is that the bugs in assembly programs usually cause immediate crash of the program and this making the fixing easy. Defer crashes and strange/random/undefined behavior of bugs in assembly programs is rare. IMO, this is because of reduced count of abstraction layers.
- harveywi 9y agoThanks for sharing! This is really interesting, especially the part about the reduced count of abstraction layers. Do you think the abstraction layers are the problem, or the fact that the overwhelming majority of "abstractions" that materialize in modern high-level software are leaky?
- johnfound 9y agoWhy adding abstraction layers makes programming easier? Because allow the programmer to not think (and even know) about some things and leaving them to the layer/libraries. But every layer adds also a level of obscurity. The interaction between multiply layers is even more undefined and random. It is OK while everything goes as expected. But when there are problems, the obscurity can make the debugging a hell. In addition, the behavior of the bugs hidden deep in the layers (or in the way the layers interacts in between and with the application) can be really weird. That is why, IMHO, the programmer should keep the abstraction layers to the minimal count that allows solving programming tasks with minimal effort, counting not only the coding time, but debugging and supporting time as well. In my practice, I decided that using FASM with Fresh IDE and set of assembly libraries gives me the needed quality of the code.
- 2ton_jeff 9y agoThis is a sad statement. Proficiency in a given language/environment dictates how long and painful a solution will be. Use cases for this are no different to any computing-related task, though I concede it isn't for everyone :-) Neither is Python, Perl, Java, JS, Node, and hey, lets throw in COBOL because you know, there was never a use case for that either. /sarcasm
- pjmlp 9y agoAssembly IDEs are still quite common on embedded space, and TASM back in the day had a Turbo Vision based IDE on MS-DOS. And on the Amiga we had DevPac.
- TylerE 9y agoIt would make a better first impression if your hero screenshot didn't have font rendering from circa 1995.
- ungzd 9y agoYes, it does not look like website of another Node.js framework or adtech startup. Another culture of software has another website aesthetics. And yet it looks better than average "modern" website. Fonts are of adequate size, contrast is high, no "carousels", no videos.
- topspin 9y agoThe UI is simply what you get with the classic win32 API. It is instantly comprehensible and workmanlike, if not contemporary chic. It is also crazy efficient; that API and the widgets and controls it provides were developed when machines had 4MB-8MB of RAM. The whole IDE probably launches in a few milliseconds and fits in L2. Cool stuff.
- Encounter 9y agoOr if the site was usable on mobile.
- wolfgke 9y agoRather tell this to the vendor of your preferred mobile browser.
- Uehreka 9y agoI know that comment seems superficial, but when I saw the Windows 98 style GUI, I actually thought that perhaps this was an abandoned project someone was bringing up for nostalgic purposes.
- johnfound 9y agoThe screenshots are taken in Linux: XFCE+Wine. Fresh IDE is actually some kind of hybrid application. It works in Linux better and with more features than in Windows. :)
- chrisparton1991 9y agoThe HTTP response code for fresh.flatassembler.net assets is "200 She'll be apples", I didn't know 200s could be customised like that :)
- exikyut 9y agoI know the fasm forum is powered by rwasa, perhaps fresh. is too. https://2ton.com.au/rwasa/ https://2ton.com.au/rwasa/ is based on https://2ton.com.au/HeavyThing/ https://2ton.com.au/HeavyThing/, a library written for fasm that handles a bunch of cool things including enough crypto to do TLS and enough network code to make a webserver.
- 2ton_jeff 9y agoHahah, proper Aussie mate! (there's a compile-time flag to make them all boring instead of our homage to Aussie slang haha, cheers and glad you like it)
- exikyut 9y agoHi! I thought the response string was rwasa's fault :) Question. I've just started to become interested in learning/messing around with assembly language under Linux, and fasm seems like a really attractive option - as and nasm are both tied to gcc (nasm indirectly), and fasm skips all that (and produces slightly smaller binaries too!). fasm also seems compiles itself in less than a second on my really old machine as well, and fast iteration time is one of my favorite features. Linux-specific assembly-language documentation is kind of rare on the ground though; for fasm in particular, there's literally hens' teeth and dust bunnies. It's very possible to piece things together, but if you have absolutely no idea what you're doing it's a bit intimidating. HeavyThing is practically a tutorial in and of itself, but I must admit my hesitancy to lean too heavily on it due to its use of GPLv3. I certainly respect the use of that license (and understand the many reasons it might be used for such a unique project), but I'm only tinkering around myself at this point so would likely want to use MIT, CC0 or similar, and would feel a bit conflicted about the predominant thing I learned from being from GPLv3. HT is on the list for sure, but I wanted to combine it with other sources of info. You seem to be one of the few people out there actively using fasm for Linux development, so I figured it couldn't hurt to ask if you had any other high-level suggestions.
- dguaraglia 9y agoOh boy, the memories from all the "IDEs" there were for NASM. In the end, it was just easier to use your favorite editor, because most of them just had a pretty color scheme for assembly. This looks pretty sweet, though.
- baldfat 9y agoAS a kid I remember those days. I spent like $100 because the IDE was going to help me crack all the gamez. Whelp that was a sorry waste of money.
- dguaraglia 9y agoHaha, I managed to crack a couple programs by following the +ORC cracking tutorials and a (cracked, of course) copy of SoftICE. In fact, that's how I got interested in assembly. Then I learned C and started using Linux as my operating system, so I didn't have a need for either thing anymore :/
- truncate 9y agoJust curious if they wrote the IDE in assembly (my instincts say not, but they do make assembler). The login is giving 404 https://fresh.flatassembler.net/fossil/repo/fresh/fossil/repo/fresh/login https://fresh.flatassembler.net/fossil/repo/fresh/fossil/rep...
- 2ton_jeff 9y agoThe IDE is indeed written entirely in assembly language, as is everything from the webserver up (JohnFound, author of FreshLib/FreshIDE also wrote a fastcgi layer to interconnect with rwasa from my own goods). Everything there is assembler.
- zerr 9y agoThis is not the assembly we remember from TASM/MASM days though. It seems to include quite many high level constructs.
- 2ton_jeff 9y agofasm was in fact modelled after early TASM, and much of the "high level constructs" are just macros... or did you mean something more specific?
- wruza 9y agoAt the time I lost my interest to assembly, it had pretty high-level contructs like looping, function frames, structs, etc. via macros. Macros of fasm are iirc recursive, so its power is far more than usual assembler. I would put it at 85% on [regular asm .. non-optimized C] scale. You can think of tasm/masm as of lisp with cpp instead of macros. The use case beyond educational purpose is still unclear to me though. Especially with macros.
- johnfound 9y agoYou always can reduce the usage the of macros or make them more assembly-centric. Check the Fresh IDE sources as an example of moderate macro use. On the other hand, definition of complex data structures is much easier with powerful macro engine.
- shash7 9y agoOn a side note, check out how they have laid out the curved screenshot. It is apparently a stack of images. That helps setting the text to follow the couture of the curve.
- Klathmon 9y agoThere's actually a CSS property just for this called `shape-outside` [0]. It lets you define a shape of an image (or other element) that makes it so when it is floated, other elements can wrap up against it correctly. [1] is an example I just quickly made to show how the linked page could have been done in straight CSS. It works a bit nicer too as the text smoothly wraps instead of stepping like the linked article does (although there is no reason why both methods can't be combined to provide a smooth stepping where possible, and fallback to the approximation they used when it's not supported) It's browser support is pretty awful right now (only chrome, safari with the `-webkit` prefix, and basic support in firefox behind a flag), but if it makes it to standardization, it's a pretty neat tool to be able to reach for in these cases. If there were an easier way to see if the website itself was open source, I'd try and give it as a quick patch, but it doesn't look like the website itself is open source anywhere that I can find. [0] https://developer.mozilla.org/en-US/docs/Web/CSS/shape-outside https://developer.mozilla.org/en-US/docs/Web/CSS/shape-outsi... [1] https://jsfiddle.net/c1ffdpgq/2/ https://jsfiddle.net/c1ffdpgq/2/
- TremendousJudge 9y agoYour example doesn't work in Firefox (text doesn't wrap properly), but it does in Chrome
- jerianasmith 9y agoWith too many high level constructs, i also feel it looks quite different from TASM days.
- kitd 9y agoI like the example project that compiles a source file into a Mandelbrot image.