To Apply Complete This Form And Return With A Check For Amount Due: Fill & Download for Free

Obtain the 2016 IRS forms or tax software, complete your tax return, compute your 3 year late filing penalty, write a check for the amount owed, make sure you have that amount of money in the checking account and mail to nearest IRS office designated for receiving tax returns. Don't forget to apply correct postage. If the return is accepted as correct, your late payment will be accepted. If the amount due is disputed by IRS, you will receive correspondence by mail stating that you either owe more money or your return has been corrected. Best to do the same for any other late filing tax years as swiftly as possible as late filing fees are onerous. If the late fee is quite substantial, consider hiring a tax attorney to attempt to negotiate a settlement. If you are lucky you may gain a substantial discount.

I grew up 30 miles from the birthplace of the Republican Party. And I was a public school teacher in that state, the son of two public school teachers in that state.Let me tell you what the Republican Party did to my first career as a public school teacher.First, a little background, because this is actually relevant.Teaching in Wisconsin up to 2010When I was young in the 90’s, the economy was doing pretty well, and the teachers’ union was hauling districts to arbitration over pay raises.See, the private sector was doing great. Folks were getting thousand-dollar bonuses just because the companies were doing awesome. Raises were common, often 4–5% a year.Districts didn’t want to pay that, so the unions took them to arbitration, and arbitrators consistently came back with awards consistent with the prevailing wage increases of the private sector.So Republicans passed a law called the Qualified Economic Offer, or QEO. Basically, as long as the districts and state offered a certain percentage increase, the unions were banned from taking it to arbitration. It was about 2.5–3%. At the time, all my folks’ private sector friends were laughing at my parents.After the dot-com bubble burst and took a sizable piece of the economy with it in the early 2000’s, that laughing turned to resentment after a couple of years when the teachers were still getting raises slightly over the cost of living while the private sector had seen serious contraction.Bush deregulated the health care industry, and premiums and deductibles started skyrocketing. When I was a child, a thousand dollar deductible was considered outrageous and only for catastrophic insurance at the fringes of the market. My uncle recalls that family health insurance when I was a child, whole family insurance with dental and vision, was $40 a month through his employer. By the time I was a teenager, that had more than tripled for the average family.So, suddenly, this QEO was looking no longer like a way to stick it to the teachers and keep them from these massive arbitration awards and resentment grew at the “sweet deal” giving teachers a raise above the private sector every year. So, it was repealed by those same Republicans.I graduated from college right about the Great Recession. I was student teaching while it happened. I watched the markets crash every day when I checked the Dow at the end of school.My mentor teacher had been on a wage freeze for five years. (To pre-empt the peanut gallery, yes, Democrats were in charge of the state during that period. The question asked about what Republicans have done, and it’s not a binary white-hat-black-hat situation.) What she was forced to pay into health insurance had gone up by 10% in that span; literally every year she was making less than the year before in take-home pay.It was pretty grim for teachers at that time in 2008–2009. We all thought it was the bottom.Then the Tea Party took over.Scott Walker and Act 10In 2010, Scott Walker got elected. The very first thing that he did upon taking office in 2011 was to gin up a financial “crisis” for the state by using some accounting tricks to come up with a three-billion-dollar budget shortfall and claiming the state was flat broke.[1][1][1][1] He used this justification to ram through, with as little public debate as possible, breaking multiple open meetings laws and open records laws, a bill called Act 10.[2][2][2][2]Act 10 was aimed at gutting public sector unions, particularly targeting teachers and municipal workers. The police and fire unions, in a naked display of political favoritism, were exempted because they supported Walker’s election bid.The Act kept unions alive in name, but puts draconian restrictions on them. The only thing that the unions can bargain collectively for now is over base wages, capped at inflation and based on the lowest rung of any pay scale used. A 30 year veteran teacher with a master’s degree would only see a raise capped at inflation and based on a first-year teacher’s salary, if any raise were issued at all.Unions now have to recertify every single year, not by a majority of votes cast, but a majority of possible votes. Anyone choosing not to vote is considered a no vote, in other words. Failure to recertify means that the union was dissolved and barred from re-forming for five years.Public sector unions are barred under Act 10 from collecting “fair share” payments. Under Federal laws, unions must represent all workers in a place of employment, whether they are part of the union or not. Fair share laws were designed to fix the “freeloader” problem; they provided a reduced payment collected from non-union employees to offset the cost of the fact that the union had to negotiate their contracts as well.Since the unions now had to cover the entire state’s public employment, but could essentially no longer collect any dues or fair share payments from anyone who didn’t want to pay up, and because they were relegated to essentially powerlessness over any working conditions, union enrollment dropped by more than half virtually overnight.Oh, it gets better.See, Walker made the assumption that teachers paid nothing towards their health care insurance and pensions.Some districts, as a fringe benefit to make up for low salaries, had been paying the employee’s share of the required pension payments. Additionally, unions had made the choice to push for continued benefits like health insurance rather than salary increases over the years. Other districts, especially rural districts with declining enrollment, had been already requiring their teachers to pay more significant costs towards health care for several years already.Walker’s assumption was that every school district had been giving their employees everything for free, and that’s how he sold it to the people of Wisconsin.So, that justified a $1.6 billion dollar cut to public education, which would be “made up” by forcing all teachers to pay more for health insurance and pension costs. It barred districts from making up any of that cut by increasing property taxes. The average district cut was in the millions of dollars.In the first district I taught in, this resulted in every teacher taking between a ten to twenty percent pay cut.Act 10 gutted tenure protections and civil service protections, to “give districts tools” to manage these draconian cuts. It was supposed to make it easier to fire bad teachers. In the hands of honest administrators, it did.In the hands of dishonest administrators, we ended up with what Hustisford School District chose to do: fire every single teacher in the district and offer them their jobs back… at first-year salary. A 30-year veteran teacher with a master’s degree would have to return to work with an effective 50% pay cut, and be paid the same as a teacher fresh out of college with a bachelor’s degree.The UW SystemMore cuts were leveled at the University of Wisconsin System, one of the oldest completely public higher education systems in the nation, and the most extensive system of technical colleges, 2-year colleges, and 4-year institutions in the country. My alma mater was saddled with enough cuts that it is now facing a five-million-dollar-per-year structural deficit. As with the public school districts, those cuts came with specific bars against raising tuition to make up any difference.Walker’s justification was that all of these cushy professors were only teaching one or two classes and worked less than ten hours a week. This was rated “pants on fire,” but that didn’t stop Republicans from reciting the party line.Wisconsin is now absolutely desperate for public teachersAfter eight years of this, Wisconsin’s enrollment in teacher training programs is at record lows. Ten percent of the profession quit within the first year after Act 10 passed.[3][3][3][3] The attrition rate still remains above the national average.Rural districts with low tax bases are especially hard hit. High-tax-base communities like Mequon can afford to pay substantially higher salaries and benefits, and so they poach more qualified or highly-respected teachers from rural or lower-base areas.My brother-in-law, an orchestra teacher, was offered a five-figure signing bonus and a 10% salary increase to switch districts across the state to a wealthier community. Great for him; can’t blame him for taking it. The more rural community he left is now considering cutting the orchestra program because they can’t find a teacher willing to take the job. They’ve been making do with a band director who doesn’t really know strings for two years.It’s gotten so bad that legislators have considered multiple proposals to offer provisional licensure to people who have literally no educational or pedagogy training whatsoever if they have any experience tangentially related to the field they want to teach in.Technology education has been especially hard-hit, because those teachers realized five years ago that they could make twice as much in the private sector as engineers and welders.Morale is at an all time lowMy friends who are sticking it out in education right now are reporting that morale has never picked up even a little bit in the last six years.Communities in general continue to believe that teachers are getting a sweet ride at the public trough, even though more and more of them are needing to take up second jobs to make ends meet. One of my best friends works at Olive Garden three nights a week and on weekends to pay her bills. Another works the security gate for Fleet Farm so he can grade papers while at his second job.In my last year of teaching, I was called a glorified babysitter by a parent at a conference. I did the math on the board right in front of them, just for their kid, for the amount of time I spent with that kid, at $5/hour. It was more than their property taxes. (That parent got pissy and left my room in a huff when I figured the final numbers.)Why did I leave?I was doing nothing but fighting battles for my students. I was putting in, on average, a 75–80 hour work week, and 90 hours a week was not uncommon. I’d get to school at 6:30 am to beat the copier rush, and typically stayed until 5–6 pm working with students, to go home and down a bite of whatever I had in my constantly-running crock pot, and grade and lesson plan until 10 PM to midnight. Lather, rinse, repeat. 12–14 hours on Saturday, often another 6–10 on Sunday; more if the end of a quarter approached.And I made $35,500 for that.The school board came out with a new wage schedule for us that it expected would cover the next thirty years.If I got every raise, every pay scale step increase, got a master’s degree and National Board certification, never got married, had a child, or incurred any serious debts, and assuming the long-term average in the stock markets and that Walker didn’t screw up the pension system (something he’d been considering,) I calculated that I’d likely be able to retire at 76.Seventy-six.If I lived frugally and saved wisely and was very, very lucky.I asked some of my friends what they thought. They all pointed out that I’d considered law school in the past, and that I had a passion for much of what I could do there.I made the decision to apply to law schools, resigned my teaching position, and never looked back. And I have never regretted that decision for a moment.The attitude towards education in the Republican Party has gotten worse, not betterI’ve attended various Republican Party meetings, trying to change things from the inside. I despair that nothing will change their minds, and if anything, anti-intellectualism has gotten more entrenched.From fears over Common Core standards to the pervasive belief that public education is simply a waste of money and we should all go back to private schools and homeschooling, it is clear to me that the beliefs in the Republican Party right now are decidedly against public education.I’ve heard nothing but praise for Betsy DeVos as she attempts to dismantle the Department of Education. (If only it weren’t for that “deep state” that stymies her! Actual thing heard at one of these meetings with knowing nods all around.)A significant majority of the people at these meetings either homeschool their kids or send them to private religious schools. Those who do not are mysteriously quiet and will not meet my eye when I try to get their views on the topic.When I ask about the local schools, most reply that their local public school is pretty good. However, they will invariably tell me that they are absolutely certain that public education itself is failing and that schools elsewhere are terrible because something something PARCC and international tests. Do they know how standardized tests work? No. Would they like me to explain it to them? Eyes glaze over.I’m one of them, you see. Those edumacated folks. Those people who think they know more because they got a piece of paper hanging in their office. (I’ve been told this to my face and heard it plenty of times behind my back.)The Republican Party doesn’t want to see public education. They want to see publicly funded education, and that as limited as possible. They want their children to go to schools that teach an ideology that they want, and to keep their kids away from certain other kids.And so public schools will simply continue to become a dumping ground for high-poverty students and kids with special needs.Elsewhere around the countryRepublican stronghold Kansas has been forced to go to a four-day week amidst teacher shortages because they can’t even fund schools enough to keep the lights on that long. Teachers have to have the four-day week to get second or third jobs to afford to make it work.[4][4][4][4]Teachers are fleeing South Carolina[5][5][5][5] and other typically red states to work in states that are adequately funding education and fostering public respect towards teachers.Why is the Republican Party often portrayed as being against public school teachers?Because my experience, the experience of my colleagues, and the evidence all suggest that they are.Footnotes[1] Wisconsin Gov. Scott Walker says Wisconsin is broke[1] Wisconsin Gov. Scott Walker says Wisconsin is broke[1] Wisconsin Gov. Scott Walker says Wisconsin is broke[1] Wisconsin Gov. Scott Walker says Wisconsin is broke[2] Wis. Assembly Cuts Union Rights[2] Wis. Assembly Cuts Union Rights[2] Wis. Assembly Cuts Union Rights[2] Wis. Assembly Cuts Union Rights[3] Here's what happened to teachers after Wisconsin gutted its unions[3] Here's what happened to teachers after Wisconsin gutted its unions[3] Here's what happened to teachers after Wisconsin gutted its unions[3] Here's what happened to teachers after Wisconsin gutted its unions[4] Amid teacher shortage, four-day school districts can't afford to go back, superintendents say[4] Amid teacher shortage, four-day school districts can't afford to go back, superintendents say[4] Amid teacher shortage, four-day school districts can't afford to go back, superintendents say[4] Amid teacher shortage, four-day school districts can't afford to go back, superintendents say[5] Classrooms in Crisis: Why SC teachers are quitting in record numbers[5] Classrooms in Crisis: Why SC teachers are quitting in record numbers[5] Classrooms in Crisis: Why SC teachers are quitting in record numbers[5] Classrooms in Crisis: Why SC teachers are quitting in record numbers

TL;DRThe answer is huge, but (hopefully) quite comprehensive. I programmed on C# / .NET for almost 10 years, so I know it really well. And I program on Python at Quora for ~ 7 months now, so I hope I know it pretty well.Python is winner in: ease of learning, cross platform development, availability of open source librariesC# is winner in: standard library, language features, development process and tools, performance, language evolution speedRoughly even: syntax (Python is better in readability, C# has more consistent syntax), adoption.SyntaxPython pros:Usually shorter notation:indentation, “:” and “\” instead of “;”, “{“ and “}”no need to decorate any identifier with its type (or “var” in C#)no need to specify function argument types and return typeno need to nest each function into a classno need to use public / protected / private; you should follow “_name” or “__system_name__” convention, but it’s anyway shorterno need to type “new” to invoke constructorGenerator / list comprehension expressions tend to be very short as well.C# pros:More consistent syntax and formatting rules. I can't remember any inconsistencies in C#, but instantly wrote this list of inconsistencies in Python:the fact that assignment expression is not an expression at allold and new class syntax (“class X:” vs “class X(object):”)weird base method call syntax: super(ClassName, self).method_name - it violates DRY twice and doesn’t work for old style classesdifferent formatting rules for = in regular assignment expressions and function arg. spec."except SomeError, error" syntax: show this fragment to someone who never seen Python and ask him what it might meanexception from common rule in tuple syntax: ( (), (1,), (1,2) )class methods: IMO this feature just pollutes standard polymorphism by adding no any significant improvement; worse, people frequently misuse it (e.g. always prefer class methods to static methods)the way Python deals with self / cls (I’ll discuss this in performance section) looks like a leaky abstraction; this adds noticeable performance impact as wellthreading.local is one of the worst abstractions I’ve ever seen; C# offers few options here, but the most widely used is [ThreadStatic] attribute turning static variable into thread-local static. But in Python you must inherit your class from threading.local to ensure its instance fields are thread-local. So same instance sees different fields in different threads. The abstraction is bad not just because it looks like a huge hack, but also because it requires you to write more code (additional class) in typical scenario (thread-local static variable).system method names with double underscores on both sides make you feel like you write on C :) (4 additional symbols for any of such names)In few cases - shorter or cleaner syntax. E.g.:lambda expressions and LINQ (vs generator expressions in Python) are shorter and more readable in C#lower_case convention for method / function / local names (i.e. most of names) in Python requires more keystrokes than camelCase convention in C#. Basically, you do 1-2 additional keystrokes per each identifier.Language featuresPython features, that don't map well to C# features:everything is dynamic. Sometimes this is really useful - e.g. you can add your own “tags” (fields or methods) to nearly any object, or use "monkey patching" (What is monkey-patching?) to change the behavior of third-party code. It’s arguable if it’s good from design point, but there are cases when it’s really nice to have such an opportunity. You can achieve something similar in C#, btw - e.g. by employing dependency injection, extension methods + weak references, but this is more complex. On the other hand, it makes you think more about the architecture that enables you to make such changes without hacky tricks.decorators: there are equivalents in C#, but Python’s decorators are definitely unbeatable in simplicity and flexibility. Closest C# equivalents: nearly any DI container capable of aspect injection (in particular, based on decorator-like attributes); PostSharp aspects.*args, **kwargs - most of static languages don't provide such a way to enumerate/pass call arguments. On the other hand, there are lots of ways to process all arguments in C#:.NET Remoting infrastructure allows to get call arguments in runtime, but this is pretty slowYou can generate a class wrapper using one of code generation facilities (CodeDom, Reflection.Emit, etc.) and do the same fastFinally, if you use dynamic objects, you deal with arguments by nearly the same way as in Python.yield expressions: yield can both accept and return value in Python, but in C# it can only accept a value. On the other hand, it looks like you can implement a very similar logic with async/await (await accepts and returns a value).Class methods: actually it’s good C# doesn’t have this feature :)“with” contexts in Python can process exceptions: __exit__ method there gets information about thrown exception. Unfortunately this is impossible in C#: IDisposable.Dispose() has no any arguments there. The feature can be really useful in some cases - e.g. when you need to make a commit/rollback decision inside block exit code. But you can handle this with nearly the same amount of delegate-based code in C#: dbContext.Transaction(() => { /* code */ }Python features, that can be mapped to C# (i.e. there are close abstractions):list comprehension syntax and generator expressions: LINQ to enumerable (LINQ in general is way more powerful)generator methods: methods returning IEnumerable<T> and IEnumerator<T> in C#. Actually, this feature is implemented in more solid fashion in C#: result of IEnumerable<T> method can be enumerated as many times as you want, and result of IEnumerator<T> method can be enumerated just once. Now look how it works in Python:In [1]: def gen():  ...: yield 1  ...: yield 2  In [2]: g = gen()  In [3]: [x for x in g] Out[3]: [1, 2]  In [4]: [x for x in g] Out[4]: []  In [8]: g = gen()  In [9]: for x in g:  ...: print x  ...: if x == 1:  ...: break  ...: Out[9]: 1  In [10]: [x for x in g] Out[10]: [2] lambda expressions: the same in C#; you can get ~ AST of such an expression in C# too. As I’ve mentioned, C# notation for lambda expressions is shorter: “lambda x: x + 1” in Python is “x => x+1” in C#dynamic typing: dynamic keyword in C# + DLR infrastructure. IronPython/IronRuby are built on it.runtime code generation / parsing / evaluation: lots of facilities in C#: lambda expressions, System.CodeDom, System.Reflection.Emit, third-party wrappers helping to implement typical tasks, and finally, compiler-as-a-service in C# 5named parameters and default values: works ~ the same in C# in terms of syntax.tuple expressions (tuple syntax): C# doesn’t provide any syntax sugar for this, but there are tuples (i.e. regular classes).regex syntax: the same.Now let’s look on C# features, that are missing in Python. I’ll list just the most important ones from my own point of view, but you can get a good imagination of the whole list by looking up this feature-by-feature comparison of C# and Java.Multithreading: Python, in fact, is single threaded: there are “threads”, but Global Interpreter Lock (GIL) allows just one Python thread to execute at any given moment of time (except the case when one of threads awaits for IO completion). There are Python implementations w/o GIL - IronPython (.NET-based) and Jython (JVM-based), but since library developers assume there is GIL, you actually can’t rely on GIL absence even on these platforms. Absence of multithreading brings really big performance-related disadvantages for web apps (pretty unexpected, btw, if you didn’t face them) - but I’ll cover this in performance section.Generics and structs: on one hand, Python doesn’t need generics, since it’s dynamic. On the other hand, they frequently provide huge benefits in terms of memory and speed in C# - even in comparison to Java with its type erasure based generics. E.g. if Vector3D is a struct of 3 doubles in C#, var list = List<Vector3D>(...) will really use ~ list.Length * 3 * sizeof(double) amount of RAM for it, and will be represented by just 2 objects in heap (List<T> + Vector3D[] - the underlying array it uses for storage). But Java should allocate ~ list.Length of objects in heap for this list: each Vector3D is represented by an object in heap there, so totally it uses at least 3 * list.Length * pointer_size more RAM for this. And Python should allocate ~ 4 * list.Length objects in heap (both Vector3D and double are in heap there).LINQ: it isn’t the same as list comprehension in Python:List comprehension is specific syntax sugar available just for iterables in PythonLINQ is syntax sugar as well, but it isn’t bound to a particular generic type: it works for any generic type meeting few expectations. In particular:If this type is IEnumerable<T>, it’s “LINQ to enumerable” - a set of extension methods operating as list comprehension in other languagesBut if this type is IQueryable<T>, it’s what normally referenced as LINQ - a technology allowing to transform a query expression on C# to query on virtually any other language. In particular, it’s LINQ to SQL, LINQ in Entity Framework and so on.Finally, underlying type can be your own. Few examples: LINQ to observables (Reactive Extensions) and parsing monad.Interfaces. They're really good, if the same contract is implemented by several classes.Extension methods: pretty nice feature, actually, although it’s just a syntax sugar improving code readability. Anyway, I used them in C# (mainly to add helpers to some built-in and third-party types like IEnumerable<T>, IRepository<T> and some enums), and their absence in other languages makes me a bit disappointed. You can use "monkey patching" in Python, that's something very similar, but not the same: extension methods don't change the original class and are applied if you import a namespace declaring some of them. So different code can import different extension methods (even if they have identical names).Enumeration types. They’re implemented super-well in C#, and it’s quite good to have this feature integrated.Method overloading: no analogue, but you can handle different argument sets differently in the same method in Python (although usually this is more complex). Method overloading is something natural for static languages, but quite unnatural for dynamic ones.More native code, less interop / plumbing code. C# is fast, so normally you deal just with C# while writing on it. The same isn’t valid for Python: it’s a bad idea to implement nearly any algorithm requiring huge amount of RAM or CPU resources in Python; you’ll quickly learn that nearly any code requiring high performance must be written on C++. All this implies that:If you develop a realtime web app on Python, I’m 99% sure you’ll end up writing few modules on some other (faster) language - e.g. C++. Maybe it’s just 1-2% of the codebase, but it’s +1 language to learn and +1 dedicated subsystem to maintain. Besides C++, you need to know how to interact with C++ code from Python, i.e. how to write some plumbing Python code enabling the interop.Compare this w/interop in C#: I suspect 99% of web apps written on C# don’t have any C++ code at all, because it’s ~ as fast as C++; there are few pretty rare cases when you need C++, but they’re really rare. And even if you’ll ever need this, C# provides really awesome interop capabilities.async/await, Task Parallel Library and Parallel LINQ: they’re really useful in C#, and honestly, most of other languages don’t offer anything similar in terms of usability. But since Python doesn’t support concurrency, this is even worse there. Probably, parallel processing in Cython is one of the simplest options available, but even it looks more as workaround having really limited application scope rather than a full solution, and AFAIK, we never used it practically.Standard libraryC# definitely wins here: its BCL is:better designed (more classes, less static functions)strictly follows naming guidelines (there are lots of names violating PEP8 in its current class library - they’re there mainly for compatibility)better documentedand finally, it offers more abstractions.I can't say Python BCL is totally bad, but it really look worse in comparison to .NET.Development process and toolsI used:C#: Visual Studio .NET (2005, 2008, 2010 and 2012) w/ReSharperPython: latest PyCharm, Vim and some Unix tools like grepPython pros:Interactive Python. You can test lots of small things instantly.Fast startup / restart. Even such a large application as Quora starts in ~ 5 seconds on my devbox. That’s actually a very good property: it doesn’t add a significant friction if you used to do small iterations.No need to compile the project. More precisely, you _almost never_ need to compile the project: I estimate nearly any complex project has some non-Python code + some parts requiring Cython (Python-to-C compiler).No need to maintain project files. I mean *.csproj and *.sln for C# - usually they’re managed by Visual Studio .NET, but almost any complex project requires some of them to be modified manually.C# pros: most of C# pros are based on fact that it is statically typed, so development tools can rely on this. I’ll list just the most importantCorrect intellisense suggestions. I’d estimate that PyCharm provides a correct suggestion only in 30% of cases.Correct refactorings. Nearly any refactoring in PyCharm requires manual fixes. I’d say PyCharm dependency detection gives some false positives in 30% cases, and false negatives in 10% of cases, so you always need to supervise this. And that’s really annoying in case of really large refactorings (100+ usages). Most of Python developers use grep for this, and that’s way more complex. I’d say, that’s probably the biggest disadvantage: you can easily spend 10+ minutes (in some cases - an hour or so) on actions that take 1 minute in ReSharper.Way better “online” error detection / highlighting. The most typical example: if PyCharm is incapable to derive the type of x, don’t expect it highlights x.soemthing as an error. The same never happens in case with C# (of course, if you don’t use dynamics).ReSharper provides way more helpers - mostly, stub generators. E.g. "implement /extract interface" or "implement equality members" is something I used to. PyCharm has nothing similar (probably, because Python doesn't support interfaces :) ). But anyway, the point is: despite the fact C# requires you to write more bolerplate code, nearly all typical code can be quickly generated by tools like ReSharper. So you actually don't feel any friction about that.VS.NET provides better support for related tools and technologies. Full support of e.g. Razor ASP.NET MVC templates (intellisense, navigation, errors, etc.), ASP.NET MVC itself and languages like Less/Sass is really useful: you do way less actions to add somethign standard.Compilation detects may be 50% of errors even before launching the code. Yeah, that’s one of benefits of statically typed language: you don’t need to run the code to detect pretty large part of errors.Better debugger, integrated profiler. I can’t say PyCharm is bad here (no profiler, but its debugger is very nice), but I have a feeling that VS.NET offers more useful options.Relatively fast compilation and startup. “Relatively”, because it is way faster than e.g. GCC; startup is fast if you pay attention to this - actually it’s pretty easy to make it slow, especially for a large app.Overall, I think C# is definitely a winner in scope of this section. Python clearly gives some benefits if your codebase is relatively small, but most of them turn into disadvantages when it becomes large (or huge). E.g. pretty big amount of friction associated with refactoring makes developers to postpone this, that eventually increases technical debt. I can’t say if snowball effect is highly probable in this case, but at least its probability seems higher.PerformanceDisclaimer: I never studied CPython code, so a part of further statements explaining how it works internally might be false: I reason about this mainly by applying my Python debugging experience + general logic. Nevertheless estimated timings provided here are well-aligned with actual measurements, so hopefully, if there are some mistakes, they aren’t vital.That’s the most painful part of comparison for Python. CPython (most widely used Python interpreter) has a set of issues related to performance, and I’ll try to cover most important of them here; many of such issues are related to other dynamic languages, but definitely not all of them.It also worth to mention there is PyPy claiming to be almost 6x faster than CPython; on the other hand, so far we couldn’t reach any speedup by running Quora on PyPy. I can’t fully explain why, but I feel this is mostly because:We use Cython to improve performance at all major hotspots; it’s tiny % of codebase, but it looks like we’d have 30-50% worse performance w/o Cython. So CPython our codebase actually isn’t a pure Python codeIt seems PyPy isn’t quite efficient for applications having huge codebase and large working setWe didn’t try to implement any PyPy-specific optimizations in PyPy branch.Currently performance of PyPy branch is ~ the same or slower as performance of primary CPython branch; I’ll update this section if there are any changes.So why CPython is slow? Let’s start from Alex Gaynor’s presentation:Slides: Why Python, Ruby, and Javascript are Slow (https://speakerdeck.com/alex/why-python-ruby-and-javascript-are-slow)Video: Why Python, Ruby and Javascript are Slow, Rdio's Alex Gaynor at Waza 2013It worth to look all the slides, but I’m going to describe what actually happens in CPython on this particular example. Fast-forward to slide 24: https://speakerdeck.com/alex/why-python-ruby-and-javascript-are-slow?slide=24 (https://speakerdeck.com/alex/why-python-ruby-and-javascript-are-slow?slide=24)Alex lists 3 allocations done by this code, but reality seems to be way worse - it’s actually pretty tricky to even list all the stuff involved there:Python: int(s.split("-", 1)[0])a) s.split(...) involves:a dictionary lookup for "s" name. Few dictionary lookups, if this happens inside a closure (or few nested ones).a dictionary lookup for “split” method of “str” typecreation of a bound method object even before call, i.e. a allocation of a new object in heap:In [3]: x = "a".split In [4]: y = "b".split In [5]: x is y # “is” performs reference comparison in Python Out[5]: False In [6]: z = str.split In [7]: z is x Out[7]: False In [8]: x1 = "a".split In [9]: x1 is x Out[9]: False This happens because methods are actually descriptor objects in Python. So when is executes some_object.some_method(some_value), actually few dictionary lookups + few allocations might happen:CPython looks for “some_method” in “some_object”’s dictionary (actually, its class object, but let’s assume we still have constant lookup time assuming inheritance hierarchy is tiny)And tries to get __get__ member of this object - to check if it’s a descriptor or not, so probably it’s +1 lookup (actually I hope system methods invoked by CPython itself are invoked ~ like virtual methods in C++, i.e. it’s fast). Since some_method is instance method, there is __get__ memberCPython invokes this __get__ member. To invoke it, it must construct and pass a tuple with its arguments. Quite likely, +1 allocation - it’s pretty unlikely they’re passed as structs on stack.__get__ should return a bound method instance, i.e. it’s +1 allocation in the best case as well.Likely, some_method call implies allocation of a new tuple object containing all passed arguments - i.e. (some_value,) in our caseSince we invoke a bound method, there can be two tuples: normally bound method adds self to a tuple passed to it, i.e. produces another tuple: (self, some_value)Probably this isn’t intact for methods that don't accept **kwargs, but the ones that do require a new dictionary to be constructed (pretty large object).So:instance method access =~ 1 dictionary lookup + 2 allocations/deallocations + 1 VMT-like lookup (__get__ member search)instance method call =~ at least 1 dictionary lookup + 4 allocations/deallocations + 1-2 VMT-like lookupsb) split(...) result is a list, which is usually composed of two objects: list wrapper + array, that's re-allocated when list reaches its current size limit. So if it returns a list of 2 strings, there must be at least 4 new objects in heap (list, wrapper + 2 strings).c) ...[0]: works nearly any other method call. Fast languages allow to turn off bounds check for such ops, but effect of doing this in Python must be negligible in comparison to other expenses.d) int(...):a dictionary lookup for "int" name. Few dictionary lookups, if this happens inside a closure (or few nested ones).likely, one tuple allocation (for method call arguments)So let's count the minimum number of dictionary lookups and allocations/deallocations for this simple code:Dictionary lookups: 1 + 1 + 1 = 3Allocations/deallocations: 4 + 4 + 4 + 1 = 13Quick measurement shows that Python needs at least ~50ns for dictionary lookup, and ~50ns for allocation. It’s more difficult to measure deallocation time, but it’s safe to assume it is comparable to allocation time. So expected performance limit of this piece of code is:50ns * 3 + (50ns + 50ns) * 13 = 1450nsChecking with %timeit:In [1]: s = '1-' In [2]: int(s.split("-", 1)[0]) Out[14]: 1 In [3]: %timeit int(s.split("-", 1)[0]) 1000000 loops, best of 3: 1.80 us per loop So actual time is 1800ns.Now let’s calculate what time the same operation could take in C#:C#: int.Parse(s.Split('-'))[0]:3 static class, 0 virtual calls. Static call require ~ 1ns in C#1 string[] allocation, if string.Split is optimized pretty well; small object allocation require ~ 10ns in C#2 string allocation, if Split produces 2 stringsNo need to count deallocation time, since it’s nearly zero for any short-living objects in languages with true generational GC w/compactions.So this code should require at least 33ns in C# (I'll add actual measurement result later here). Actually it should take a bit more, since Parse and Split do some job, and it should be probably comparable to these 33ns in terms of CPU consumption time. But even this simple calculation shows this code must be ~ 44x faster on C#; likely the same is valid for other similar languages (Java, Scala, etc.).So let’s summarize some of CPython issues related to performance, that were exposed here:1. Lots of allocations / deallocations, that are costlyThanks to:Bound methods, and likely, a convention of passing arguments as a tupleThe fact that nearly any variable (even local) is stored in heapAbsence of generics and structs. On contrary, these two things together make C# code almost as efficient as C++ in terms of RAM consumption.Finally, CPython uses ~ regular memory allocator. This mean that it should find a large enough space in heap to allocate the object and track the fact this space is used, and do the opposite on deallocation. This happens in any case, i.e. for small, short-living objects as well.Now imagine, .NET needs just to move the pointer + clean up allocated block for any typical allocation, and does virtually nothing for typical deallocation (really: Garbage collection (computer science)). So .NET heap acts much more like a stack: there is no need to look up for free space to allocate some RAM, and no need to worry about deallocation, since there is GC, that touches just live objects, and knows absolutely nothing about dead ones. And since most of objects are short-living, .NET spends zero resources on deallocation of most of objects. Certainly there is amortized deallocation cost, but it's way smaller than in Python (may be it's smaller even than in C++, btw) due to this fact.This explains, btw, why Java is nearly as fast as C#, although there are no structs and true generics: this stack-like heap behavior makes allocations/deallocations of small objects really cheap - almost as cheap as placing them on regular stack (structs and other value types in .NET live on stack). So basically, Java may be slower due to this only when lots of such objects are long-living, so they're promoted to higher GC generations, and this adds some pressure on full GC cycles. This affects on CPU cache hit ratio as well, since any object in heap has additional header (16 bytes in 64-bit processes on .NET; not sure about Java), so if objects are small, % of excessive data in continuous block of RAM can be pretty high - e.g. at least 80% for such blocks of integers. But anyway, that's Java; Python has way more serious issues here.2. Relatively large objectsMost of objects are dictionaries, so they tend to consume several times more RAM than e.g. in objects C#. Efficiently this reduces the size of CPU caches by the same factor. But L1/L2 misses are super-expensive - they can easily slow down your code by an order of magnitude, and Python programs tend to get these 10x way easier.3. Bad garbage collection (GC) implementationCPython doesn’t have true generational GC. That's mentioned in 1), but here I'd like to show few more side effects of that:It never moves objects in memory (Do python objects move in memory during execution?), thus there are no "true" generations defined by border addresses in RAM (I suspect generation is just some mark in object's header there)It uses reference counting + likely, mark and sweep-like collector to find and remove garbageThere are generations, but it looks like they aren’t quite helpful: GC pause can easily take few seconds, if you have a large heapWhy it’s bad?No compactions = RAM fragmentation + bad CPU cache utilization. For comparison, .NET tunes up GC in such a way that Gen0 is always inside L1 CPU cache, and Gen1 is inside L2 CPU cache - i.e. most frequently accessed objects are cached quite efficiently in C#, and almost always aren’t in cache in Python - due to RAM fragmentation and significantly larger average object size. Details: Garbage collection (computer science)Reference counting = global interpreter lock = no true multithreading + no benefits of fork()-ing the process to share a single copy of code and initial data set across several Python processesGC pauses are proportional to the amount of RAM used by your application. Thus CPython app using multiple GB of RAM and running without pauses of several seconds (if not minutes!) is something impossible. Actually even an app using about hundred of megabytes requires special GC tweaks and manual GC cycles to avoid pauses at random moments.Finally, I found it quite misleading that "gc" module documentation doesn't reflect this: 27.12. gc - Garbage Collector interface - Python v2.7.5 documentation. Worse, if you look on descriptions there, I bet the initial impression you'll get is: "cool, it has generational GC!". There are parts that might make an experienced developer to suspect the opposite (can you find them, btw?), but I feel like the only conclusion most of people can make is that Python has nearly the same implementation of GC as other modern languages. And that's misleading.4. Lots of dictionary lookupsPython uses dictionary lookup to resolve address of nearly any symbol (even local variable). Dictionary lookup time is ~ 50ns there (btw, it’s nearly the same in C# for Dictionary<K,V>).Static languages (including C#) resolve virtual method addresses using Virtual Method Table lookup, and such lookup usually takes 2-3ns to complete..NET code uses dictionary lookups just in one case: when it invokes virtual generic method parameterized by generic type(s) (i.e. the call looks like someObject.SomeMethod<T1,T2,...>(...)) - dictionary lookup is the only option it has in this case. But this is relatively rare thing, actually - especially for hotspot code. And even this dictionary lookup usually takes ~ 20ms there.5. Multithreading and related issuesAs I wrote before, Python, in fact, is single threaded. And just one this things makes it impossible to implement e.g. such optimizations available for web applications on .NET:Any in-memory caches: you can share them across all the threads serving web requests on .NET, but you can’t do the same in Python, since there is no point to handle more than one web request in a single Python process (if it doesn’t wait a lot of time in IO, of course). So you can assume each web request handler written in Python is actually a process with its own address space, and thus you can’t share caches across such processes. So if you run e.g. 16 Python processes on web tier machine, you can assume that effective cache size is ~ 1/16 of cache size for the same .NET app. You can try to tackle this issue by running a process maintaining shared cache for multiple Python processes, but you’ll get additional interop expenses (serialization and deserialization), that add a huge overhead in comparison to direct memory access.The same is actually related to Python code itself. Imagine you run a large web application, that allocates 100MB right on start for code and data. So if it’s .NET application, it can utilize threads to service concurrent requests, there is just one instance of these 100MB of shared stuff. If 5-10MB of it is the part that’s used most frequently (working set), you have a good case, since it’s close to L2 CPU cache size. Now imagine the same in Python: 16 similar processes allocate 1.6GB of right on start; working set size is 80-160MB, which is far beyond L2 cache size, so just one this thing slows down everything by may be a factor of 10. Probably you think you can fork a single Python process to ensure there is a single copy of these 100MB, but this won’t help much: CPython mixed garbage collection utilizing reference counting, so basically, if you reference / dereference something (e.g. copy a reference to some object into local variable), this counter changes its value. So any memory page containing any object from this hot set has nearly zero chance of staying unmodified - i.e. nearly all pages after forking will be copied pretty fast by each of such processes.Above issues are way more painful for Python web apps than e.g. absence of TPL, PLINQ and async/await analogues: you get parallelism almost for free here, so additional parallelism is actually rarely necessary. But this “free parallelism” in .NET is actually way better then “free parallelism” in Python.Cross-platform development supportPython clearly wins here: C# works very well on Unix under Mono, but it’s mostly about its base class library. Nearly anything tightly bound with Windows isn’t available there. Incompatibility map: Compatibility - MonoAdoptionRoughly even: PYPL PopularitY of Programming Language index - pyDatalogAvailability of open source librariesBased on my experience, Python and C# roughly even in terms of availability of free / open source third-party libraries. Nearly all you need to develop a web application is free on .NET.But Python has definitely more open source projects on GitHub: Top Languages · GitHub (many C# projects are hosted on http://www.codeplex.com/ - originally it was the best place to host your own C# project, but right now it’s GitHub, so I think it’s fair to ignore this).So Python is winner here.Ease of learningPython seems way easier to learn:Basic syntax requires you to know less language constructions - e.g. no program in C# can be written w/o declaring a class; you need to know what’s compilation, assemblies, namespaces, classes, methods, public/private/static keywords, etc. On the other hand, you can write a program even without declaring a function in Python. So it’s easier to learn Python iteratively: you need to know almost nothing at start, and use more and more features while studying it deeper. In contrast, C# requires you to learn way more before you even start to write your first program on it.Interactive Python provides really nice way to learn the language and run quick tests.Python standard library is mostly built over functions - there are just few classes, no any complex inheritance, etc.; in contrast, C# base class library is fully object-oriented: lots of classes, sometimes - deep inheritance. Moreover, some parts of it require you to understand functional concepts very well - e.g. as I wrote, LINQ in C# is way more powerful than list comprehension syntax in Python, but that comes with associated learning expenses: list comprehension syntax in Python is, in fact, just a nicer way to write loops, and thus it’s super-easy to explain this. And LINQ is, in fact, a syntax sugar for defining Monads in C# + implementations of some of them (IEnumerable<T>, IQueryable<T>). This description highlights the difference very well :) And LINQ isn’t the only example: there are few other parts of C# BCL that require you to deeply understand all the concepts; try learning WPF, for example.You need to know a set of specialized tools to write on C#. E.g. I used Visual Studio .NET with Resharper and a set of other plugins, Far (it’s like Midnight Commander, but for Windows), Redgate .NET Reflector and IIS on daily basis. And most of people writing on Python use just Vim/Emacs + a set of standard Unix tools. Not sure what’s better here in terms of learning curve - basics of VS.NET are pretty easy to learn; on the other hand, a typical Unix developer doesn’t need to learn any new tools at all to develop on Python, assuming he already knows Vim and unix tools like grep. But... Typical Windows developer knows VS.NET as well :) Anyway, the point is: there are simpler (i.e. less advanced than for C#), but more generic development tools for Python.Language and runtime evolution speedI feel like C# evolves way faster:Versions of C Sharp (programming language)Python Releases