Jump to content
  • Advertisement

Mike.Popoloski

Member
  • Content Count

    2279
  • Joined

  • Last visited

Community Reputation

3259 Excellent

About Mike.Popoloski

  • Rank
    SlimDX Primary Code Monkey

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. Mike.Popoloski

    Down with the FastCall22 reign!

    All the old school GDNet members have been chatting on #gamedev (irc.afternet.org) for going fifteen YEARS now. Not sure why they felt the need to embed a crappy broken webchat thing.
  2. Mike.Popoloski

    Unique Style of Flow Control

    This is just a way of hiding the fact that you're essentially using "goto". If that's what you really want, man up and just use "goto ErrorHandling;" I've seen similar styles of using for(ONCE) { }, with the idea that you use break to jump to the end of the block. Once again, it's just a disguised goto. If you put your "failable" code into a function, then you can use return and have the calling function have the error handling / cleanup code. As coding patterns go, this is much less likely to confuse people.
  3. Mike.Popoloski

    Programmers talk "Alien"

    OK.
  4. Mike.Popoloski

    Speculation on semantically-aware version control

    This is essentially exactly what we did with the content streams system, and it's one of the primary reasons we did it.   We also discussed how this could be extended to code; essentially, you pretend the code is "content", in the form of the AST. Thus, you can do merges at the semantic level instead of the dumb textual level that version control systems typically support.
  5. Mike.Popoloski

    Hard lessons

    You might want to take a look at how Mono handles frame pointer omission in a managed context and see if you can adapt that into your code generator. Since the code is actually kind of hard to navigate, I went ahead and linked some of the relevant areas for you:   https://github.com/mono/mono/blob/master/mono/mini/mini-x86.c#L969  - Cases where they're able to omit the FP.   https://github.com/mono/mono/blob/master/mono/mini/mini-x86.c#L1038  https://github.com/mono/mono/blob/master/mono/mini/mini-x86.c#L2408    They use a "save_lmf" variable that holds the Last Managed Frame and saves some metadata about it when they encounter a stack frame that jumps into a P/Invoke or other native call, and then they ensure that they reset it when they pop that frame again.   It might be a bit more troublesome to handle for your case, since you're not doing JIT and thus don't have some of the luxury of figuring out some of that stuff at runtime, but then again they have to go much further to make sure everything gets reset properly.
  6. Mike.Popoloski

    The Importance of Commenting Your Code

  7. Mike.Popoloski

    Release 14 imminent...

    Why do you have to spill the registers at all? Can't you keep track of which ones have references in them?
  8. Mike.Popoloski

    Real-world garbage collection with LLVM

    Nice. I'd like to work on a GC at some point; they're cool bits of software.   You should go all out and make yours generational.
  9. This is a fairly terrible article, and I don't think it's safe to say that it could be revised into anything useful. Even disregarding whether the conclusions are accurate (I don't believe they are, for many of the reasons laid out by others here), this is much better as a blog post than as an article. It provides no useful design techniques or guidance, has an overly informal and almost childish tone, and in fact seems to provide no actual information other than "people should make infinite games, and everyone is dumb for not doing it".     Really? Really?  Why is this even under review. It should have been weeded out before it even got posted.
  10. Mike.Popoloski

    When Boredom Strikes

    Now you need to write an assembly program that when run emits a PE file that initializes D3D11 and then launches that executable.
  11. Mike.Popoloski

    Slow progress...

    The TPL makes asset management a complete breeze. Pretty much any kind of concurrent programming is just gloriously easy to do in C# these days. All the synchronization primitives, lockless collections, and various ways to asynchronously run tasks just makes that traditionally painful multithreaded programming job much easier. Just wait until you get into the new async/await features. You're a little late to the party though with LINQ. They've got a new experimental library in the works called Reactive Extensions that turn the "pull" concept of iterators on its head for "push" style event-based stream processing. It requires a whole different way of looking at things, but it lets you write some very intuitive code once you wrap your mind around it. I've been thinking about how to apply it to entity systems in a game.
  12. Mike.Popoloski

    More steroids for Epoch's type system!

    So does Epoch get an asterisk next to its name in the record books?
  13. Mike.Popoloski

    Laserstrike for Zen X-Fi 2

    Hawt.
  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!