• Content count

  • Joined

  • Last visited

Community Reputation

551 Good

About ATC

  • Rank
  1. I'm aware of that. But how would you suggest approaching the design then?
  2. Swiftcoder has made a very good point... dealing with multiple threads... Now that I consider this, perhaps I can redesign the allocation process to create a dictionary of NativeMemoryManager instances indexed by the hash of thread it was created on. That way each thread in the application has its own instance. If the thread is terminated prematurely all resources could be released (EDIT: Unless another thread requires them)...
  3. [quote name='L. Spiro' timestamp='1352345902' post='4998728'] All-in-all, very practical to implement. Only the way the animation system runs needs to be modified, and that modification is trivial, since it is extremely easy to calculate what kind of impulse needs to be applied to get from one orientation to another over a fixed amount of time. [/quote] Could you explain how you would go about making those calculations? I'm considering implementing this and some other things...
  4. I'm aware of the numerous problems that can arise through the use of the Singleton pattern, which some go as far as calling an [i]anti[/i]-pattern... One of the biggest problems is all the references to the global instance/state, for example: [source lang="csharp"] // inside method body... var obj = Something.Get(); obj.TakeAction(); obj.Whatever(); [/source] This can really complicate testing and make code that's difficult to maintain... However, I'm wondering if the Singleton pattern is not ok (or even [i]optimal[/i]) for certain circumstances when only one, globally accessible instance of something should exist... Consider the class I'm currently working on. It is called "NativeMemoryManager", and it is essentially a "safe" API for allocating, manipulating and releasing unmanaged process memory within a .NET application (it uses a 1:1 wrapper I wrote of the CRT memory management API as its back-end -- this is all part of my generalized application & game development framework). NativeMemoryManager inherits "DisposableObject", which is an abstract class that offers a robust implementation of the IDisposable interface; all instances of which are pushed into the "ObjectTable" which is traversed at application shutdown to destroy potential memory leaks... Only one instance of NativeMemoryManager should ever exist. It's only field is a data table which stores critical information about all memory allocations to prevent memory errors and free any unfreed memory when the application is shutdown. It doesn't need multiple states, and I don't foresee myself ever wanting to replace the singleton instance with some sort of testing instance. Also, if I implement any objects which need to use/consume NativeMemoryManager I will make that object accept the instance in its constructor and store it locally: [source lang="csharp"] public SomeType( NativeMemoryManager mem ) { this.nativeMem = mem; } [/source] Then it will use the reference its stores rather than calling NativeMemoryManager.Obtain() over and over... So considering this particular case and others like it, do you see any problem with using the Singleton pattern? Or is there a better way to approach this?
  5. How powerful is Java?

    [b]@ Aeramor[/b]: I agree with pretty much everything you said. I've never liked Java. I won't say language A sucks or language B is the greatest, but Java always seemed slow and unstable to me, whereas C# applications are snappy and responsive like C/C++ applications. I also agree that Java IDEs don't even hold a candle to Visual Studio; its really the best IDE for Windows available, and you can also of course use it to develop cross-platform applications. However, I disagree with this: [quote name='Aeramor' timestamp='1352149825' post='4997731'] If your end goal is to be an engine developer somewhere like Epic or Rockstar games you need to be learning C++ [...] [/quote] Yes, he does need to be learning C++... but not because it's the only path to being an engine developer, but because knowing C/C++ is an essential skill for any game programmer worth his salt! The 2000-teens are going to be the era of the managed engine. For years gamers have been accepting a lot of unstable code (consider Skyrim's tendency to CTD and lose textures at run-time) because applications/games are growing so large and complex that no mere mortal can manage all of its memory and resources. In this context C# and the CLR looks more appealing every day because its gains in memory efficiency, stability and type-safety are beginning to make it a more performant choice than native languages. This is precisely why my company is developing a managed engine in C# instead of using the traditional approach of C++... Regards, --ATC--
  6. How powerful is Java?

    Programming languages do not have any quality or property called "power"... So you'll never see anything like: Language: C++ Horsepower: 700 Torque: 580lb-ft There's simply no such thing... [img][/img] Some languages perform differently from others, but there are no hard-set rules about performance either. Generally, languages compiled to machine code (native binary for the CPU) are faster than "JIT'ed" managed languages which are faster than interpreted languages. But there are even exceptions to this general rule... On quite a few occasions I've written and tested C/C++ and C# code side-by-side and seen the C# code out-perform the native code. There are various articles you can find online if you're more interested in language performance. Any language that is Turing-complete (which is pretty much [i]every [/i]programming language) is theoretically capable of calculating/simulating the entire history of the known universe; provided it runs on a system with unlimited memory. Therefore there's no reason you cannot create the same game in C, C++, Java, C#, Visual BASIC or assembly language. Regards, --ATC--
  7. Question for programmers

    [quote name='gunmaster55555' timestamp='1351882069' post='4996630'] Hey so I am just getting into programming and I just want to ask a question for you programmers out there. Do you actually know in your memory what most of your coding you are doing is? Whether it be a big project or anything do you ever have to use a book/google to figure out how to do something? I am more curious because I have the mindset that I should be able to do everything without ever having to look something up and this is more for me to know if I am just setting my need to know way to high or whatever. Thanks in advance to anyone who responds! [/quote] You will ALWAYS be referencing documentation, books, manuals, etc during your programming career. APIs are so big these days no mere mortal can remember everything. It's also completely normal to need to refresh your memory on certain programming techniques as well. Being a good programmer is NOT about memorization... you can memorize, say, the entire Win32 API and still be a lousy Win32 programmer... a good programmer knows how to [i]design[/i] his/her software and turn those designs/ideas/concepts into good, working, maintainable and modular/reusable code. It's more like painting a picture than memorizing the answers to a math test.
  8. I've been screwing around for a good while on writing a C# API for retrieving live equity (stock) quotes. Tonight I got it working and I'm pretty impressed! This is pretty cool! [img][/img] As of right now the project is really an experimental rough-draft... no where near a [i]real [/i]API I'm willing to put my name behind... But what I'm wanting to know is if people would be interested in this. Would you be interested in a very fast and easy-to-use C# API that can accept any stock ticker symbol and return a full, real-time quote, from which you can easily read the data and integrate it directly into your software? If this might be of interest to you then vote up and/or reply to this post; if it seems like a good handful of people might be interested in this I will write a usable version of the aforementioned API and offer it as freeware -- free of any charges or royalties. Since I've already gotten all the details worked out and have a working mini-prototype the work will not take me too long! I just don't want to do all the work if no one wants it! The API returns stock quote objects that look a bit like this:: [source lang="csharp"]public class StockQuote{ /*----------------------------------------------------------------------------- * FIELDS & PROPERTIES :: *-----------------------------------------------------------------------------*/ /// <summary> /// Ticker symbol of the stock /// </summary> public string Ticker { get; set; } /// <summary> /// Name of the company /// </summary> public string CompanyName { get; set; } /// <summary> /// Description of exchange on which stock is traded /// </summary> public Exchange Exchange { get; set; } /// <summary> /// Name of base currency in which prices are quoted /// </summary> public string Currency { get; set; } /// <summary> /// Last trade price /// </summary> public float Last { get; set; } /// <summary> /// Today's high price /// </summary> public float High { get; set; } /// <summary> /// Today's low price /// </summary> public float Low { get; set; } /// <summary> /// Today's total trade volume (in n-shares) /// </summary> public uint Volume { get; set; } /// <summary> /// Average daily volume /// </summary> public uint VolumeAvg { get; set; } /// <summary> /// Total market capitalization /// </summary> public double MarketCap { get; set; } /// <summary> /// Today's opening price /// </summary> public float Open { get; set; } /// <summary> /// Last session's closing price /// </summary> public float PrevClose { get; set; } /// <summary> /// Net change for the day (in points) /// </summary> public float NetChange { get; set; } /// <summary> /// Net change for the day as percent /// </summary> public float PercentChange { get; set; } /*-----------------------------------------------------------------------------* ******************************************************************************* *-----------------------------------------------------------------------------*/};[/source] Sooo... let me know! Feel free to post any suggestions/ideas as well! ;-) Regards, --ATC--
  9. [URL=""]Here[/URL] is an absolutely wonderful operating system development tutorial series by "Brokenthorn"... this helped me [i]immensely [/i]in learning how to develop operating systems [i]in Visual Studio[/i], making working kernels and drivers as PE images (EXE and DLL files), configuring Visual Studio to compile properly, assemble assembly code, automatically deploy your kernel on your virtual machine for debugging and much more. It also has tutorials on implementing both basic and advanced graphics shells with working code and implementing a basic C Standard Lib and C++ runtime. It's awesome... trust me... :-) --ATC--
  10. What languages are "low-level" and "high-level" can be a matter of perspective... A "low-level" language is a language which is more closely attuned to the underlying architecture of the machine, whereas a "high-level" language is more "human-friendly" and abstracted... If you ask a web developer or Python programmer what C is they will tell you C is a "low-level" language... but if you ask an OS programmer from a Linux project they will probably tell you C is a "portable, high-level programming language"... However, all will tend to agree that assembly languages are low-level because there is generally no abstraction whatsoever -- just op-codes that represent binary operands...
  11. [quote name='lride' timestamp='1351434170' post='4994712'] I of course tried this, but I asked this because I didn't know what to put in the constructor [source lang="cpp"]Menu::Menu() { subMenu=new Menu()//?? } [/source] [/quote] If you define an object type which invokes its own constructor within its constructor (like you've done above) it creates an infinite recursion, which is similar to an endless loop. Example :: [source lang="cpp"] class MyClass { public: MyClass() { myClass = new MyClass(); } MyClass *myClass; }; void main() { MyClass* mc = new MyClass; } [/source] As soon as the "main" function of this program starts it creates a new MyClass instance and invokes its constructor with the new operator... and then what happens? Control jumps to the MyClass constructor, MyClass::MyClass()... but the code in the constructor AGAIN invokes the constructor with the new operator, in an attempt to instantiate the myClass instance... but that myClass instance will have its own myClass instance too lol... So the constructor is invoked again, and again and again and never stops... at least not until you terminate the program! ;-) A better way to handle this dilemma is allow the constructor in [i]your [/i]program to take a Menu* parameter for its sub-menu... let outside code create the sub-menu (if the menu has one) and pass it to the new, primary menu instance. Alternatively you could offer a static (or even an instance) method in the Menu class, like [static] Menu::AddSubMenu(Menu* primary, <creation params> ) or [instance] Menu::AddSubMenu(...) and let that method handle adding the sub-menu to the primary menu...
  12. I'm about to deploy a new DLL, and I'm wondering about something... I have a structure in my library called "Rational", which essentially represents a fraction -- much like SlimDX.Rational... Mine, however, is a much more powerful mathematics structure that can do all sorts of things, such as calculating the GCD/LCD, reducing fractions, arithmetic with fractions, convert from fractions to decimals (and vice-versa) and more... However, in my structure I define conversion operators that can convert MY Rational type to/from SlimDX.Rational... Problem is, I'm deploying this structure in a library that is intended as a generalized application development framework... users may or may not have SlimDX or be using it at all... for many users they will not be referencing SlimDX, and many may not even have it installed. It's my understanding that this should NOT be a problem and it would only cause my library to crash if someone tried to call a method that used a non-existent dependency... since these are operators and cannot be called directly that should never even happen! So am I right? Is it ok to leave my conversion operators in there for the benefit of SlimDX users, or must it be removed? Thanks, --ATC-- P.S. -- I could really use some help with [URL=""]this question[/URL]... hundreds of views, no answers... surely someone has deployed commercial libraries before and needed to register them?
  13. Hey guys, I have a C# library that's almost finished that's about to go into testing... I need to make an installer for it that will register the assembly with the GAC and install the DLL on the end-user's machine. I have both Visual Studio Pro 2008 and Express 2012 (Complete); since I wanted to use C# 5.0 and .NET 4.5 I did development in VS 2012 Express, but I guess I'll be using 2008 Pro to create my installer project and make my MSI file. Can someone give me a run-down of what I need to do? Are there any restrictions on where the DLL should go? How to go about GAC registration through the installer? Any of info that could be helpful? Thanks! Regards, --ATC--
  14. [quote name='Bentm's Games' timestamp='1351441513' post='4994745'] can u people quit discussing os development. All i want is something to create an inmteractive program. If coding is needed, I would prefer python or java and btw, whats svg [/quote] Well, your thread suggests you were interested in OS development... if you're not, then I have no idea what you're trying to do (or better yet, [i]why[/i] or what the point is)... You're initial question has already been answered though, just use whatever graphics API you're best with... Anything will work...
  15. [b]@ Shrinkage ::[/b] Very good and interesting post... I +1'ed it! However, I'd like to point out a few things... For starters, while your idea is great and makes me want to try it myself, which of the two is cheaper: [b]1) [/b]free download of Sun's Virtualbox and/or free download of Microsoft's Virtual PC [b]2)[/b] going out and buying physical hardware like you describe? Obviously, #1 is a lot cheaper and more accessible for "the crowd". Secondly, most of us programmers are writing software for x86/64 systems. And when we want to learn about OS development it's usually [i]not [/i]to try to become a professional OS developer (very tough market to get into, dominated by Microsoft) but to go on an "academic" venture; to become more knowledgeable and skillful programmers on our primary development platform. So for those two reasons alone I would not go as far as saying that the x86 platform is a "horrible" choice... I think that if you're in OS development for academic reasons you should work with the platform you do most of your userland/everyday programming on... and if you're in it to make a profession out of OS development you should work with the platform you intend to support. However, I must agree that learning the x86/64 architecture is quite difficult; the learning curve is steep, the manuals are thick and Intel is not exactly what I'd call a "n00b-friendly" company lol. There are lots of little tricky caveats, traps and pitfalls... lots of weird things you must learn, like setting up a GDT (global descriptor table) as an off-the-wall example... But if you learn this stuff you walk away knowing what makes your PC and your primary OS (be it Windows, Linux, etc) tick. It's hard to even describe in words how incredibly valuable that can be to a PC programmer... say you're writing an performance-critical function that needs to move and/or compare large blocks of memory as quickly as possible. Without experience in low-level/systems programming, you're like to just to take the most direct, straight-forward (and naive) approach to your algorithm. With such experience, however, you know how the CPU, data bus and RAM work... you know how memory is moved in/out of registers, to and from RAM and understand virtual memory and paging/caching... you would also know that on 32-bit architecture the CPU registers are 32-bits in size and natively move d-words (32-bits of data) faster than it can move 64-bits (and vice-versa on x64 platforms). Armed with that sort of knowledge you will almost always know how to implement the best possible routines. However, if you're a PC programmer by trade and all your OS development experience is on some completely different platform there can be quite a few gaps in your knowledge... So I encourage people to work with the platform that's right for them... and if you're a PC developer then you may as well bite the bullet and learn the x86/64 platform. If, however, you are wanting to make a career or serious hobby out of OS dev then choose the platform you need to work with and heed Shrinkage's advice... and learn more than one platform! Regards, --ATC--