Dev-C++ is a good IDE for programming in C++. It supports both MinGW and MSVC compilers and includes useful features like syntax highlighting, integrated debugger, profiler, and TO-DO lists. It's best suited for small to medium-sized project development and is particularly popular among beginners and students.
This tutorial assumes you're running Windows XP or later. While newer versions of Windows are recommended, Dev-C++ works well on older systems.
Python has some exciting news: Python Enhancement Proposal 3000 (PEP 3000) states that the Py3k project will lead to a new version of Python that will no longer be compatible with 2.x. This is a major milestone in Python’s evolution, and it’s coming later this year.
The original PEP 3000 was written in April 2006 by Guido van Rossum, and since then, the Python core developers have been actively working on this ambitious rewrite. The fundamental principle behind Python 3.0 is simple but radical: break backward compatibility to fix longstanding design issues and clean up the language.
After more than 15 years of development, Python has accumulated technical debt. Some design decisions made sense in the 1990s but have proven problematic as the language matured. Rather than continue patching over these issues, the Python team decided a clean break was necessary.
As PEP 3000 explicitly states:
There is no requirement that Python 2.6 code will run unmodified on Python 3.0. Not even a subset. (Of course, there will be a tiny subset, but it will be missing major functionality.)
This is unprecedented for Python, which has historically maintained excellent backward compatibility. But the benefits of cleaning up the language are deemed worth the migration pain.
While the full list is extensive, here are some of the most significant breaking changes:
The print statement is being replaced with a print() function:
# Python 2.x
print "Hello, World!"
# Python 3.0
print("Hello, World!")This change provides more consistency and flexibility, allowing print to be used like any other function.
Division behavior is changing to be more intuitive:
# Python 2.x
>>> 3 / 2
1
# Python 3.0
>>> 3 / 2
1.5
>>> 3 // 2 # Use // for integer division
1The current behavior where / performs integer division on integers has confused many newcomers. Python 3.0 makes / always perform true division.
All strings will be Unicode by default. The current unicode type will become the default str type, and the old 8-bit str type will be replaced by bytes:
# Python 3.0
s = "Hello" # This is Unicode
b = b"Hello" # This is bytesThis fundamental change addresses one of Python 2’s most painful areas: text vs. binary data handling.
Many methods that currently return lists will return views or iterators instead:
dict.keys(), dict.values(), dict.items() return viewsrange() returns an iterator, not a listmap(), filter() return iteratorsThis improves memory efficiency and performance for large datasets.
Python isn’t leaving developers stranded. Python 2.6, scheduled for release later this year, is designed as a bridge version. It will support forward compatibility in two important ways:
1. Py3k Warnings Mode
Python 2.6 will include a special warnings mode that alerts you to code that won’t work in Python 3.0:
python -3 myscript.pyThis will warn about deprecated features at runtime, helping you identify problematic code before migration.
2. Backported Features
Many Python 3.0 features will be backported to 2.6, available through __future__ imports or by allowing new syntax alongside old:
from __future__ import print_function
from __future__ import division
# Now you can use Python 3.0 style in Python 2.6
print("Hello")This allows you to write code that works in both versions, easing the transition.
If you’re actively developing Python applications, here’s what you should do:
-3 warnings flag__future__: Begin importing forward-compatible features in new codeBased on current development:
The Python community isn’t rushing this transition. Python 2.x will receive bug fixes and security updates for the foreseeable future, giving developers ample time to migrate.
Breaking compatibility is painful, but Python 3.0 promises significant benefits:
Python 3.0 represents a once-in-a-lifetime opportunity to fix fundamental issues without being constrained by backward compatibility. While the migration will take time and effort, the result will be a more elegant, consistent, and powerful language.
Python 3.0 is coming, and it’s going to change how we write Python code. The break with backward compatibility is bold, but it’s also necessary for Python to continue evolving. By planning ahead and using the tools Python 2.6 will provide, developers can make the transition smoothly.
The Python community has always been pragmatic and thoughtful. This transition will be no different. It’s an exciting time to be a Python developer!
Welcome to my blog!
I'm a college student studying computer science, and like many programmers, I spend a lot of time learning new things, solving problems, and then… forgetting exactly how I solved them a few months later. Sound familiar?
That's why I'm starting this blog. It's going to be my personal knowledge base – a place where I can document useful information, code snippets, solutions to tricky problems, and interesting discoveries. Think of it as my public notebook.
I'm particularly interested in programming languages – how they work, what makes them different, and how to use them effectively. You'll probably see posts about Python, Ruby, Perl, and whatever else catches my attention.
Beyond that, expect to find:
There's so much great information scattered across the web, but sometimes it's hard to find exactly what you need when you need it. I've found myself solving the same problem multiple times because I couldn't remember the solution – or couldn't find my old notes.
By keeping this blog, I'm creating a searchable archive of everything I learn. And if it helps someone else along the way, even better!
This isn't going to be a tutorial site with comprehensive guides. It's more like reading someone's lab notebook – messy, practical, and focused on what actually works. I'll try to explain things clearly, but my primary goal is to document solutions and insights for future me (and maybe future you).
If you're reading this, welcome! Feel free to leave comments, ask questions, or point out mistakes. Programming is a journey of continuous learning, and I'm always happy to hear from fellow enthusiasts.
Here's to the start of something useful.
– Shishir