Jump to content

  • Log In with Google      Sign In   
  • Create Account


Member Since 15 Sep 2012
Offline Last Active Nov 05 2012 04:30 PM

Posts I've Made

In Topic: High-level and Low-level languages.

01 November 2012 - 02:42 PM

Low-level is my bread and butter.

I've always loved knowing and wondering what was going on underneath all these symbolic English words on my text editors, IDE programs, etc, such as "include this", "load that", "call this", "return this".

Higher-level programming means simply writing instructions in a language that is not directly, or close to being directly, executable instructions from a processor for a specific instruction set architecture(C is not really "low-level" as Assembly languages are).

Lower-level programming is writing instructions that can more closely be executed directly by the processor(Assembly or machine code).

Assembly on a specific architecture is almost the lowest you can go without almost completely sacrificing readability. Binary code or machine code is the lowest-level execution done in general, but even that can get one step lower: microcode(although useless in almost every case for developers, and always pre-coded by hardware engineers basically).

It's almost impossible to do much of anything with machine code directly because it's extremely difficult to maintain, and you'd have to literally enable yourself to think along the lines of machine instructions for every miniscule instruction done by the processor.

Assembly is much more readable, but still very, very difficult for a newcomer to really grasp(I am still in the midst of learning Assembly for x64 after first mastering 8-bit Assembly from 6502 Assembly, which was used in Nintendo Entertainment System's console in 1985).

This is why higher-level languages get things done faster, because the abstraction from the processor is defeated using other tools and programs to "translate" the higher-level instructions into a directly executable format(on the machine code level, usually).

If you really want to go to low-level, it's a definite suggestion to start with lower bit-depth processors first(through a virtual machine or such).

Although low-level has lost its spark decades ago, it's still nothing more than amazing and useful information to know how it all works from the hardware itself.

In Topic: I need help getting start with directx in c++

01 November 2012 - 02:17 PM


DX and the WinAPI are the LOWEST level APIs you can interface and develop with on Windows.

As you might suspect they are the hardest.

SDL, SFML, Allegro, etc. Plenty of APIs that will wrap the Windows API, and hide DirectX completely in the shadows from you.

This will make the developing part faster and easier, but doing it with DX and WinAPI will make the setting up part longer and more difficult.

A beginner would be better off with the wrapper APIs, because, believe me, DirectX can be one major pain.

In Topic: Is DirectX Necessary?

01 November 2012 - 02:00 PM

Some developers may prefer that you know DirectX for Windows platform-specific development, because in that case they may choose DirectX over OpenGL(even though up to certain point all advanced Windows-based games use DirectX for rendering certain aspects of graphics under the hood, but you simply don't have to code it that way from your position).

So I'd say that it isn't really necessary, seeing as most people go for cross-platform, and using DirectX itself would be harder to grant that through porting.

In Topic: Create an operating system

27 October 2012 - 02:19 PM

It's much easier to make a program act as if it were a real operating system (to some sort) than an actual operating system(and a lot more bearable as well).

And I don't think your terminology of "virtual" to "real" operating systems makes sense.

An operating system running on a virtual machine is still a "real" operating system, as it would generally carry the same instructions that would be used otherwise on real hardware directly, rather than a program acting like a virtualized version of real hardware itself.

And if you're really that eager to see how they made the video, contact them on their YouTube account.

Someone else can propose an idea, guess, or maybe know, but it's hard to tell based on just a video as to what program was used to make it.

If you want to make an operating system for real, however, you have a lot of learning to do.

Even though an operating system is still software, it's not the same as compile-and-go "Hello world!" that can be accomplished and executed in less than a minute from scratch(with the right programs, input speed, files and knowledge ready).

In Topic: How much experience is enough experience?

19 October 2012 - 03:06 PM

The thing about programming is that there will always be trouble spots for every programmer, best or worst, top or bottom of the list.

If you haven't already made a "falling blocks" kind of game, which is like Tetris(without explicitly referring to it), you should proceed on there.

Platformer games give MUCH more experience that would be applicable to the kind of game you want to make, because they incorporate the more advanced work of professional games(such as artificial intelligence, gravity, field and space dynamics, etc.).

So my advice to you is ... not quite. Even though completing a Breakout clone is already good achievement, and pong as well, and the fact that you can do artwork makes it even better.

But if I were in your spot I'd progress through a few more projects before tackling a game that'll probably be harder than you think ultimately.

By the time you've completed games like Tetris and Super Mario Bros., you are ready to set the stage on any game you want(well, the first big stage of the stages).

I say this because those are classics; a side-scroller featuring many important aspects of advanced game development subjects, and an arcade-style game with falling blocks.

But you're definitely well on your way to accomplishing the "any game" feat.

Though it wouldn't hurt to practice a bit either, but you would do better to really (and I mean really) study and learn the difficulty involved in a complicated RPG game (and even the simplest RPGs are still complicated to some extent) before tackling an entire project on it to leave it in the dust, and have to start over anew from a lesser position of development success hierarchy.

I think I'll make a tutorial series on how to implement the mechanics of RPG games in code(although I'm not any programming expert, I have experience in programming and design).