当前位置： 文江博客话题详情

更聪明的编译器、语言和框架会让程序员变得更笨吗？

发布于 07-12 01:20 字数 1431 浏览 10 评论 0原文

原文

如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论， 你可以免费 注册 一个本站的账号。

评论（30）

晚风撩人2024-07-19 01:20:45

它们不会让优秀的程序员变得更笨，而是让他们更有效率； 但它们让愚蠢的人能够编程并认为自己是伟大的程序员。

澄清：我对愚蠢没有一个准确的定义。 我所说的“愚蠢”指的是一般性的事物，即那些不应该真正成为程序员或应该尝试学习重要事物的人。 我见过很多人无法真正编码，只是从各处复制东西。 软件质量评估并不是一件容易的事情。 他们最终构建了一个蹩脚的软件，但能以某种方式工作（由于存在好的工具），这样他们就不会失去工作，并且他们认为自己是优秀的程序员，因此，永远不应该尝试学习任何东西。 相信我，我在每个优秀的开发人员身上都看到了一件事：“他们永远不会停止学习，他们不会只去学习完成工作所需的代码。” 我谈到的那些人从不尝试学习超出他们需要的东西，而伟大的工具可以减少这种“需要”。

这并不意味着 IDE 不好。 我爱他们，并认为他们应该尽可能得到发展。

They don't make good programmers dumber, they make them more productive; but they make dumber people be able to program and think they are great programmers.

Clarification: I don't have a precise definition for being dumb. From dumb I mean a general thing that is people who shouldn't really be programmers or should try to learn important things. I have seen lots of people who can't really code and just copy stuff from here and there. Software quality assessment is not an easy thing. They finally build a crappy software that works somehow (due to existence of good tools) so they don't lose their jobs and they think they are good programmers and therefore, should never try to learn anything. Believe me, there is one thing I've seen in every good developer: "They never stop learning, and they don't go to learn just the piece of code they need to complete their job." Those people I talked about never try to learn anything beyond what they need and great tools reduce this "need".

This doesn't mean IDEs are bad. I love them and think they should be developed as much as possible.

回复 原文
友欢2024-07-19 01:20:45

我认为他们允许更愚蠢的程序员，但他们不会培养更愚蠢的程序员。

I think they allow dumber programmers, they don't make dumber programmers.

回复 原文
梦明2024-07-19 01:20:45

农民是否因为使用自动化机器来种植、收割和维护农作物而变得更加愚蠢？

良好的任务自动化只会让程序员变得更高效，而不是更愚蠢。

那么我们为什么不告诉我们的孩子忘记学习数学呢，我们有计算器就是为了数学呢？ 这难道不会让我们的孩子变得更笨吗？

计算器是一种允许您执行某些任务的工具。 当然，您可以进行复杂的数学和多变量积分，但是如果不学习数学，您怎么知道您需要在给定时间执行该任务？

与编程和 SDK 一样，您可以使用预定义的代码添加大量花哨的功能，但是当您需要编写一些东西来解决问题时，世界上所有的工具和自动化都无法帮助您那里（无论如何人工智能还没有那么先进；）。

Are farmers dumber because they use automated machines to plant, harvest, and maintain crops?

Good task automation simply makes programmers more effective, not dumber.

So why don't we all just tell our kids to forget learning math, that's what we have calculators for? Wouldn't that inherently make our kids dumber?

A calculator is a tool that allows you to perform certain tasks. Sure you can do complex math and multivariable integration, but without learning math, how would you know you NEED to perform that task at a given time?

Same thing with programming and SDKs, you can throw in a lot of bells and whistles using predefined code, but when the time comes that you need to write something to SOLVE a problem, all the tools and automation in the world won't help you there (AI isn't that advanced yet anyway ;).

回复 原文
很酷不放纵2024-07-19 01:20:45

平均而言，是的。 :)

它们不会让我们成为更愚蠢的程序员。 他们所做的就是允许出现更多愚蠢的程序员（我想这意味着，平均而言，我们更愚蠢。）拥有更好的工具意味着经验不足且对 CS 概念了解不深的人仍然可以编写出以下代码：最终起作用并做了一些有用的事情。 这在用汇编语言编写时是不可能的，但在用 VB 语言编写时却是可能的。 （当然，当经验不足的人编写大型应用程序并最终在其糟糕的架构的重压下崩溃时，最终发生 WTF 式灾难的可能性更大。）

不可否认，“愚蠢”在这里使用是一个煽动性的词。 仅仅因为某人知道得少并不意味着他们愚蠢，这只意味着他们经验不足。 但重点是可以理解的。

On average, yes. :)

They don't make us dumber programmers. What they do is allow there to be more dumb programmers (which I suppose means that, on average, we are dumber.) Having better tools means that someone with little experience and a shady understanding of the concepts of CS can still crank out code that eventually works and does something useful. That isn't possible when writing in assembly, but it is when writing in, say, VB. (Of course, there's a greater chance of eventual WTF-style catastrophes when a less experienced person is writing big apps that eventually collapse under the weight of their poor architecture.)

Admittedly, "dumb" is an inflammatory word to use here. Just because someone knows less doesn't make them stupid, it just means they're less experienced. But the point is understood.

回复 原文
耀眼的星火2024-07-19 01:20:45

我认为更快的机器会让程序员变得更糟......现在大多数程序员花很少的时间编写最佳代码。 编译器无法将坏代码优化为好代码。

快速的机器意味着糟糕的程序员可以编写糟糕的代码，因为没有人知道它是坏的。 在过去，必须对代码进行处理和完善，这样它才能运行得足够快，才能以可接受的方式实际工作。

托尼

I think faster machines make programmers worse.... these days most programmers spend very little time writing optimal code. Compilers can't optimise bad code into good code.

Fast machines mean that bad programmers can get away with bad code because no one knows its bad. In the old days code had to be worked at and refined so it would run fast enough to actually work in an acceptable fashion.

Tony

回复 原文
眼前雾蒙蒙2024-07-19 01:20:45

不，

智能编译器让聪明的程序员专注于真正重要的事情，比如设计好的软件。

No,

Smart compilers let the smart programmers focus on things that really mater, like designing good software.

回复 原文
眉黛浅2024-07-19 01:20:45
s/make/allow/

少一点油嘴滑舌：它们是工具。 工具不能制造任何东西，它们也不会让任何工匠变得更好或更差。 强大的工具也不会——它们只是充当杠杆，放大特定工匠的能力（或缺乏能力）。

一些编程工具具有降低进入壁垒的效果，即使不是软件工程专业，至少也能降低应用程序的运行壁垒。 缩短开发一个可用的（或“可用的”）应用程序所需的思考量是双向的：有能力的专家可以从繁琐的工作中解放出来，并可能做出伟大的事情，但笨手笨脚的新手有时会在生产中得到他们从未见过的糟糕代码。如果没有“智能”工具，就会开始工作。 在塑造 BASIC、VB、PHP 和最近大量的 Web MVC 快速开发框架的声誉方面，后一种效果可能比前一种效果产生了更大的影响，实际上也对此类工具的总体概念产生了更大的影响。

s/make/allow/

Being a little less glib: They're tools. Tools don't make anything, and they don't make any craftsman better or worse. Powerful tools don't either - they merely act as a lever, amplifying a particular craftsman's competence (or lack thereof).

Some programming tools have had the effect of lowering barriers to entry, if not to the software engineering profession, then at least to getting an app running. Shortening the amount of thought that has to go into producing a working (or "working") app cuts both ways: Competent experts are freed from scut work and may do great things, but fumbling novices will sometimes get bad code into production that they never would have gotten working without the "smart" tools. The latter effect has probably had a greater impact than the former in shaping the reputations of BASIC, VB, PHP, and the recent spate of MVC rapid-development frameworks for the web - and indeed on the notion of such tools in general.

回复 原文
￡噩梦荏苒2024-07-19 01:20:45

更智能意味着自动化。 做重复性的工作并不会让任何人变得更聪明，所以答案是否定的。

让我通过使用计算器示例进行扩展。 用笔和纸计算平方根的技术只是一个可以学习的过程。 了解这个过程并不会让你变得更聪明，它只是让你在没有计算器的情况下计算平方根。

现在，如果您发现一种计算平方根的算法，那么这就会让您变聪明。

我们的编程工具也是如此。 为你进行内存管理的语言不会让你变得愚蠢，而能够自己进行内存管理也不会让你变得更聪明。

By smarter you mean automated. Doing a repetitive job doesn't make anyone smarter, so the answer is no.

Let me expand by using the calculator example. The technique for calculating a square root with pen and paper is merely a process that can be learned. It doesn't make you smarter to know this process, it just enables you to calculate square roots in the absence of a calculator.

Now, if you discovered an algorithm to calculate square roots, now that makes you smart.

Same thing with our programming tools. A language which does memory management for you doesn't make you stupid, nor being able to do memory management by yourself makes you smarter.

回复 原文
多情癖2024-07-19 01:20:45

它使技术水平较低的程序员更容易进入该领域，仅此而已。 它不会让一个好的程序员变得更笨。 如果他们忽视了可能提高效率的工具，他们就太愚蠢了。

It makes it easier for less skilled programmers to enter the field, is all. It doesn't make a good programmer dumber. They'd be dumb if they ignored tools that could potentially increase their efficiency.

回复 原文
孤者何惧2024-07-19 01:20:45

计算机是强化设备。 所以笨的变得更笨，聪明的变得更聪明。

Computers are reinforcing devices. So dumb become dumber and smart become smarter.

回复 原文
夏至、离别2024-07-19 01:20:45

仅当您允许他们这样做时。

如果您学习过一些困难且挑剔的东西（例如我的 Tandy 102 笔记本电脑），即使使用更智能的工具，您仍然会以这种模式思考。

当然，依靠这些工具来完成工作很容易，对此我很感激。

例如，您不会教人们如何使用台锯和钻床进行木工，而是从手锯和螺旋钻或小型手钻开始。 这样，当您转向电动工具时，您就不会做一些愚蠢的事情。

依赖工具固然很好，但知道如何在没有工具的情况下完成任务也很重要。

Only if you allow them to.

If you learned on something hard and finicky (such as my Tandy 102 laptop), you still think in that mode even with smarter tools.

Certainly it's easy to rely on the tools to do your job, and for a lot of that, I'm grateful.

For example, you don't teach people how to do woodworking with table saws and drill presses - you start with hand saws and augers or small hand drills. THat way when you move to power tools, you don't do Something Stupid(tm).

Relying on the tool is great - but knowing how to do it without the tool is important, too.

回复 原文
坠似风落2024-07-19 01:20:45

不，但它确实可以带来更好的程序和代码。

我想说的是，高级语言的技能是不同的，你需要更多地考虑抽象，有更多的 API 需要担心，而且人们期望他们的软件具有更高的质量水平。 由于上述原因，程序员面临着不同的挑战，而这些工具正在应对这些挑战。

No, But it does make for better programs and code.

I would say the skills are different at higher level languages, you need to think about abstractions a lot more, there are a lot more APIs to worry about and people expect a higher level of quality in their software. As a result of the above a programmer faces different challenges, and the tools are keeping up with those challenges.

回复 原文
请止步禁区2024-07-19 01:20:45

它们不一定会让程序员变得更笨，但它们会让程序员变得懒惰。 我发现自己这样做有时只是匆忙地完成一些代码并依赖编译器来帮助我找到所有错误，而不是一开始就把事情做好。

顺便说一下，这不是推荐的做事方式。 通常需要更长的时间。

They do not necessarily make dumber programmers, but they can make programmers lazy. I have found myself doing this sometimes just rushing through some code and relying on the compiler to help me find all of my mistakes instead of doing it right in the first place.

By the way this is not the recommended way of doing things. It normally takes much longer.

回复 原文
嗫嚅2024-07-19 01:20:45

好吧，我拥有的前两台电脑是我自己组装的。 当时这很聪明，我不太确定现在这是否能很好地利用我的时间。 我在 80 年代初混合使用汇编程序和 BASIC 进行编程，当时还是很聪明，但现在不那么聪明了。

我在这里想说的是，环境已经发生了变化，在计算中，我们必须用知识的深度来换取知识的广度，并进行必要的“简化”。 为了支持“当今计算”所涵盖的应用程序的巨大复杂性和广度，我们还被迫在更高的抽象级别上工作。 一方面，我们看到领域应用专家使用高度抽象的工具提供非常好的解决方案，另一方面我们看到计算技术/编程专家编写出优秀的代码，有能力推动整个计算行业向前发展。 称任何一方愚蠢都是煽动性的，而且可能是辩论中唯一愚蠢的部分。

在这种情况下，简化只是让更多的受众能够使用现代计算机这样的有效工具。 这是一件好事，硬核程序员不应该感到受到威胁，毕竟这是他们的宝贝。

Ok, the first two computers I owned, I built myself. That was smart then, I'm not so sure it would be a good use of my time now. I programmed in a mix of assembler and BASIC in the early 80s, again smart then, not so smart now.

What I'm getting at here is that the context has changed, and in computing we have had to exchange depth of knowldge for breadth of knowldge, with the necessary 'dumbing down' which that entails. In order to support the massive complexity and breadth of applications covered by 'todays computing', we are also forced to work at much higher levels of abstraction. On one hand, we see domain application specialists using highly abstracted tools to provide very good solutions, and on the other hand we see computing technology / programming experts producing superb code that has the capacity to bring the whole computing industry forward. Calling either side dumb is inflammatory, and probably the only dumb bit in the debate.

Dumbing down in this context is merely allowing a larger audience make use of the effective tools that modern computers are. This is a good thing, and hard core programmers should not feel threatened by it, it is after all their baby.

回复 原文
笔芯2024-07-19 01:20:45

平均而言，是的，它们让程序员变得更加愚蠢。 但这只是因为它们让那些不如我们聪明的人更容易编程，从而降低了平均“聪明度”。

:-)

一个谴责现代开发环境的便利性的聪明程序员可能并不是真的那么聪明。

On average, yes they make programmers dumber. But that's only because they make programming more approachable to people who aren't as smart as us, which lowers the average "smartness".

:-)

A smart programmer who decries the convenience of modern development environments is probably not really all that smart.

回复 原文
苍白女子2024-07-19 01:20:45

笨蛋？ 不必要。 正如之前所说，拥有更智能的工具可以让开发人员专注于更重要的事情，例如使应用程序正常运行。 我自己职业生涯中的一个相关轶事：

我不是一个熟练的数学家。 我在微积分预科课程中没及格（好吧，当然，这是因为我从来没有做过作业），甚至对一些非常基本的物理公式（例如计算摩擦力）有点生疏。 这是因为我完全缺乏实践，这只是因为我从不使用它。

以导数为例。 如果你让我找到一个函数的导数，我会找到我的 TI-89，因为我不知道如何做到这一点。 然而——我认为这更重要——我知道如何使用它。 我知道它在哪里有用，为什么应该使用它，等等。点积是另一个例子。 我知道如何使用它来计算 3D 空间中表面的镜面反射，但我不知道如何手动计算它，因为我从来不需要这样做。

我不会因此而称自己更愚蠢。 也许不够实践，但同样有能力。

Dumber? Not necessarily. As has been said before, having smarter tools allows the developer to focus on more important things, like making the application function properly. A relevant anecdote from my own career:

I'm not a skilled mathematician. I flunked out of pre-calculus (ok, granted, it was because I never did my homework) and am even a little rusty on some really basic formulas of physics (calculating friction, for example). This is because I am disparately out of practice, which is simply because I never use it.

Take, for example, the derivative. If you asked me to find the derivative of a function, I would reach for my TI-89 because I haven't the fuzziest clue how to do that. However - and I maintain that this is more important - I know how to use it. I know where it's useful, why it should be used, etc. The dot product is another example. I know how to use it to compute the specular of a surface in 3D space, but I don't know how to calculate by hand it because I never need to.

I wouldn't call myself dumber for it. Out of practice maybe, but just as capable.

回复 原文
木緿2024-07-19 01:20:45

不，它类似于类固醇（和其他提高成绩的药物）——它们可以让伟大的运动员变得更好，但它们不能让像我这样的人在 10 秒内跑完 100 米，即使我吃了整个药房的药物。 所以，上帝的 IDE、语言或框架可以让你成为一个更好的程序员，但如果你只是依赖它来完成工作，你就有麻烦了。

No, it's something similar to steroids (and other performance enhancing drugs) - they make a great athlete even better, but they can't make someone like me run 100m under 10s even if I ate a whole pharmacy of drugs. So, god IDE, language or framework can make you a better programmer, but if you're only relying on it to do the work, you're in trouble.

回复 原文
眼眸里的快感2024-07-19 01:20:45

我认为不，但是有很多人（非常聪明的人）认为不同，

我真的推荐这次讲座，这是一个非常有趣的观点和非常好的文章

I think no, but there are many people (very wise ones) that thinks different

I really recommend this lecture, it's a very interesting opinion and very good essay

回复 原文
断桥再见2024-07-19 01:20:45

我不这么认为。 更复杂的工具只会让我们的注意力集中在更有趣的问题上。

I don't think so. More sophisticated tools just frees our minds concentrate on more interesting problems.

回复 原文
一页2024-07-19 01:20:45

对于我们这些过去已经学会执行上述任务或了解上述复杂性的人来说，我相信这只会让我们更有效率。 我们可以更自由地担心其他/更重要的事情。 我们可能倾向于要么忘记“那时有多难”，要么抱怨今天的新程序员有多么幸运。

对于我们这些刚刚起步并且还没有了解这些细节的人来说，我相信这只会让我们成为一个不同的品种。 并不愚蠢，只是我们从不同的角度看待不同的问题。

然而，它确实降低了进入门槛，从而使编程更容易为大众所接受。 这是好事还是坏事还有待商榷。

For those of us who have learned to do said tasks or learned about said intricacies in the past, I believe it just makes us more efficient. We're freer to worry about other/more important things. We may tend to either forget about "how hard it was back then" or complain how lucky new programmers are today.

For those of us who are just starting out and haven't learned such details, I believe it simply makes us a different breed. Not dumber, just that we look at different problems in different light.

It does, however, lower the entry hurdle, and thus is making programming more accessible to the masses. Whether that is a good or bad thing is debatable.

回复 原文
关于从前2024-07-19 01:20:45

是的，但是没关系。 最近有人用纸和铅笔开平方根吗？ 我们使用计算器或用我们最喜欢的编程语言简单地调用函数。 我们中有多少人知道计算器的用途甚至功能？

你应该知道事情是如何工作的，你想成为更好的程序员，或者其他任何东西，你应该知道的越多。 但一天只有这么多个小时。

更好的工具让我们变得更好。 代价是我们几乎失去了对过程的控制。

Yes, but it doesn't matter. Any one extract a square root lately, by using paper and pencil? We use a calculator or simple call a function in our favorite programming language. How many of us know what the calculator does or even the function?

You should know how things work, The better programmer, or anything else, you want to be, the more you should know. But there are only so many hours in day.

Better tools make us better. The trade off is we lose little control over the process.

回复 原文
萌吟2024-07-19 01:20:45

在某种程度上

例如，我不知道或不关心如何编写运算符重载，因为我有为我制作它们的工具。 我什至不必记住 P/invoke 是如何工作的，因为我拥有的工具会自动创建一个 C++ dll 项目，并在我的 C# 项目中创建一个 [DllImport] 。 我不必为我的项目编写自动更新程序，因为 ClickOnce 几乎就是这样。 （而且我不知道它在“幕后”是如何工作的。）

所以，是的，我不太聪明，因为我不知道 C++ 程序员知道的很多低级内容。 但我仍然认为我是胜利者，因为我可以完成更多工作。 我可以花更多的时间在演示、质量控制以及客户真正想要拥有的功能上。 此外，深入挖掘 .NET 框架确实需要一些学习，因此这是一个权衡。

In a way

For example, I do not know or care about how to write operator overloads because I have tools that make them for me. I don't have to even remember how P/invoke works because a tool I have would automatically create a C++ dll project, and a [DllImport] in my C# project. I don't have to write an auto-updater for my project because ClickOnce is pretty much it. (And I have no clue how it works 'under the hood'.)

So yeah, I'm less smarter because I have no clue about a lot of low-level stuff that C++ programmer know. But still I reckon I'm on the winning side, because I can get more done. I can spend more time on presentation, quality control, and those features that customers really want to have. Also, digging deep in the .NET framework does require some learning, so it's a bit of a tradeoff.

回复 原文
未央2024-07-19 01:20:45

我不会说它们一定会让程序员变得更愚蠢，但我想说的是这一点。 对于当今时代刚刚开始开发的人们来说，并没有完全了解幕后为我们所做的事情有多少。 如今，平台中内置了如此多的库，以至于今天开始的人们不知道这一切如何必须在某一时刻手动完成。

不过，我要说的是，如果没有智能感知，我永远无法回去编写一行代码:)

I wouldn't say they make programmers dumber necessarily, but what I would say is this. For people starting out in development in today's day and age, don't have a full appreciation for just how much stuff is going on behind the scenes that's being done for us. There are so many libraries built into the platforms these days, that people starting out today have no concept of how this all had to be done by hand at one point or another.

I will say however, I can never going back to writing a single line of code without Intellisense :)

回复 原文
蓝戈者2024-07-19 01:20:45

我认为有必要拥有更智能的工具，这样我们就可以从复杂性中进行抽象层。 但我认为我们必须能够改变对这些抽象层的访问。
我认为程序员的工作效率会更高，但很容易失去许多基本概念。 这是一个权衡...
优秀的程序员将是那些不断了解编程基础知识的人。 其他人将是“复制粘贴”和乐高玩家。

I think it's necessary to have smarter tools so we can have layers of abstraction from the complexity. But I think that we must be able to change have access to those layers of abstractions.
I think the programmers will be more productive but easily will loose the notion of many basic concepts. It's a trade off...
The good programmers will be the ones that continue to understand the basics of programming. The others will be "copy-and-paste"'s and Lego players.

回复 原文
绝不服输2024-07-19 01:20:45

相反，更智能的编译器意味着您与计算机的斗争更少，并且可以更多地考虑如何尝试做某事。

如果您正在努力使用汇编程序，那么您几乎永远不会为匿名方法而烦恼。

On the contrary, smarter compilers mean you're fighting with the computer less and get to give more thought about how you are trying to do something.

If you're struggling with assembler you will almost never bother with anonymous methods.

回复 原文
巷雨优美回忆2024-07-19 01:20:45

我会说不。

更智能的编程系统（我认为更高层次的抽象，而不是自动修复代码的工具之类的东西）IMNSHO 实际上更难使用。 我提出的类比是，它们充当长杠杆； 你在短端用力真正，移动一点点，就会发生巨大的变化。

弄清楚需要做什么更难，但当你最终做的时候把事情搞砸也更难。

I'd say no.

Smarter programing systems (I'm thinking higher levels of abstraction not things like tools that would automatically fix your code) IMNSHO are actually harder to use. The analogy I have come up with is that they act as a long lever; you push really hard on the short end, move it a tiny amount and huge changes take place.

It's harder to figure out what needs to be done, but it's also a lot harder to mess it up when you finally do it.

回复 原文
琉璃梦幻2024-07-19 01:20:45

更智能的语言、编译器和框架使编程成为可能。 我的意思是，你能想象如果我们仍然限制使用汇编语言的话编程的状态吗？ 哎呀，刮掉那个。 您能想象如果我们仅限于 C 或 C++ 的编程状态吗？

Smarter languages, compilers, and frameworks make programming possible. I mean, could you imagine the state of programming if we were still restricted to using Assembly language? Heck, scratch that. Could you imagine the state of programming if we were restricted to C or C++?

回复 原文
七色彩虹2024-07-19 01:20:45

编译器、语言和框架的改进使程序员更加高效，前提是他们拥有良好的学术背景或良好的语义理解能力。

Improvements in compilers, languages and frameworks makes programmers more effective, assuming they have a sound academic background or good semantic understanding.

回复 原文
枫以2024-07-19 01:20:45

我知道这是一个旧线程，但仍然想在这里发表我的意见...

它们确实让我们变得更愚蠢，你们中大多数做出反应的人已经知道如何以正确的方式编程。 为什么？ 因为你来自一个几乎不使用框架的时代。

在教育系统中，越来越多的框架在课堂上使用，……在没有使用框架的课堂上，不鼓励开始编程。 学习所有这些代码，同时在您的脑海中您知道有一个工具可以为您完成这一切。 您知道在现场/工作场所，您必须使用框架才能快速进行。 那么为什么要花这么多时间学习代码呢？

SO：从短期来看，对于所有已经了解这些语言的人来说，不......它不会让你变得更笨。

从长远来看......你会看到低级程序员变得更好，优秀程序员变得更好等级更差。

记住我的话！

I know this is an old thread but still would like to throw my opinion on here...

They do make us dumber, most of you people here who react already KNOW how to program in a decent way. And why? Cause you come from an era that frameworks hardly were used.

In the education system more and more frameworks are used in classes,...and in classes where no framework is used, its not encouraging to start programming. Learn ALL this code, while in the back of your head you know there is a tool that does it all for you. You know in the field/workfloor you have to use frameworks to go fast. So why spend all this time learning the code.

SO: In the short run, for all you people already knowing the languages, no...it doesn't make you dumber

On the long run....you will see the low-lvld programmers become better and the good programmers become worse in lvl.

Mark my words!

回复 原文
~没有更多了~

关于作者

梦萦几度

暂无简介

文章
评论
27 人气
发私信

相关话题

更多

热门标签

操作系统 程序设计 IT运维 Linux系统管理 JavaScript 服务器应用 solaris C/C++ PHP Shell BSD Vue.js aix Oracle Python HTML 系统管理 HTML5 CSS 前端
更多

推荐作者

裸钻

文章 0 评论 0

执手闯天涯

文章 0 评论 0

2401825754

文章 0 评论 0

就此别过

文章 0 评论 0

我为君王

文章 0 评论 0

机场等船

文章 0 评论 0

更多

友情链接

文江博客
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站，即表示您同意使用 Cookies 和您的相关数据。
原文