563 reputation
313
bio website tchatzigiannakis.github.io
location Athens, Greece
age 25
visits member for 2 years, 2 months
seen yesterday

Who I am

  • Undergraduate in Electrical and Computer Engineering.
  • Member of the IEEE and the IEEE Computer Society (formerly member of the IEEE Communications Society).
  • Hobbyist programmer since the age of 10.

What I use

  • I currently prefer to develop in C# and Java.
  • I use C, x86 ASM and JavaScript situationally.
  • I've also used C++, VB.NET, Ruby, Python, PHP, Prolog, UnrealScript and Vala at one point or another.

Mar
20
comment What is the effectiveness of code reviewing by just reading?
@gnat I've done it successfully multiple times with other peoples' code. The sources of many kinds of bugs have some telltale patterns. Nobody said that this is the "typical debugging process", but it still is entirely possible and useful if you can't run it, for any reason.
Mar
4
comment Team member questioning moving from VBA to C#
An added advantage of VB.NET is that you can pretty easily combine components written in different .NET languages. So, you can (for example) migrate from VBA to VB.NET and then add new functionality in C#, VB.NET or anything else that makes sense for your project.
Jan
31
comment Finding a Pre-Written Software License
People warn against the Creative Commons license as a software license because it doesn't spell out the exact freedoms that make FOSS what it is. However, your software is not FOSS. Therefore, a CC license may not be as unsuitable as you may think.
Jan
12
awarded  Good Question
Jan
9
comment Explain MVC to non-programmers
If I had to describe it in simplified terms, I would describe it as an architecture pattern that focuses on separation of concerns - this, in turn, allows frontend developers to focus on the frontend, backend developers to focus on the backend and database developers to focus on the database, without bothering each other as much as they would in a differently structured system.
Jan
6
awarded  Yearling
Jan
4
accepted What are the caveats of implementing fundamental types (like int) as classes?
Jan
2
awarded  Popular Question
Jan
1
awarded  Nice Question
Jan
1
comment What are the caveats of implementing fundamental types (like int) as classes?
@delnan It's true I'm mostly interested in languages that abstract away the storage details, but please feel free to include anything you think is relevant, even if it's not applicable in those languages.
Jan
1
comment What are the caveats of implementing fundamental types (like int) as classes?
When talking about escape analysis, I also meant allocating to automatic storage (it doesn't solve everything, but as you say, it solves some things). I also admit I had underestimated the extent to which fields and aliasing could make escape analysis fail more often. Cache misses are the thing I was most concerned about when talking about spatial efficiency, so thanks for addressing that.
Jan
1
comment What are the caveats of implementing fundamental types (like int) as classes?
@Telastyn I can see your point, then (although I've found some uses occasionally). By the way, I was also implementing a toy language when I came up with this question. Your answer is useful to me already, but can you include some further practical caveats that you met, if any? Also, can you clarify the paragraph about dispatching to/from a CPU instruction?
Jan
1
comment What are the caveats of implementing fundamental types (like int) as classes?
@Telastyn I see your point about the overhead of an additional method call. But I don't think that inlining a call to a function of the base class library is unheard of, or unfeasible (considering that when an instance is created at a local scope or is provided through a variable of a final/sealed type, we can ignore polymorphism and statically link the called functions, even if they are virtual). Also, IMHO variance is useful, even between two types (is the relationship between object and string useless?), plus I'm not necessarily saying that int will inherit dierctly from object
Jan
1
comment What are the caveats of implementing fundamental types (like int) as classes?
int + int can be a regular language-level operator that invokes an intrinsic instruction that's guaranteed to compile to (or behave as) the native CPU integer addition op. The benefit of int inheriting from object isn't only the possibility of inheriting another type from int, but also the possibility of an int behaving as an object without boxing. Consider C# generics: you can have covariance and contravariance, but they are only applicable to class types - struct types are automatically excluded, because they can only become object through (implicit, compiler-generated) boxing.
Jan
1
asked What are the caveats of implementing fundamental types (like int) as classes?
Dec
31
revised What is different between the internal design of Java and C++ that lets C++ have multiple inheritance?
deleted 2 characters in body
Dec
31
revised What is different between the internal design of Java and C++ that lets C++ have multiple inheritance?
edited body
Dec
31
revised What is different between the internal design of Java and C++ that lets C++ have multiple inheritance?
added 624 characters in body
Dec
31
answered What is different between the internal design of Java and C++ that lets C++ have multiple inheritance?
Dec
24
comment How did OOP evolve to include the notion of Properties
Good answer, it explains the exact practical reasons that led to the introduction of properties as a language-level construct.