text
stringlengths 1
1k
| source
stringlengths 31
152
|
|---|---|
lly delayed, i.e. gains in productivity are rarely reflected in immediate profitability gains are more likely realized on the long-term.
=== Performance ===
The term performance is even broader than productivity and profitability and covers a plethora of factors that influence a company's success. Hence, well-known performance controlling instruments like the Balanced Scorecard do include productivity as a factor that is central but not unique. Other relevant factors are e.g. the customers’ or stakeholders’ perception of the company.
=== Efficiency and effectiveness ===
Efficiency and effectiveness are terms that provide further confusion as they themselves are often mixed up and, additionally, efficiency is often confused with productivity. The difference between efficiency and effectiveness is usually explained informally as efficiency is doing things right and effectiveness is doing the right things. While there are numerous other definitions, there is a certain agreement that e
|
https://en.wikipedia.org/wiki/Programming_productivity
|
r definitions, there is a certain agreement that efficiency refers to the utilisation of resources and mainly influences the required input of the productivity ratio. Effectiveness on the other hand mainly influences the output of the productivity ratio as it usually has direct consequences for the customer. Effectiveness can be defined as "the ability to reach a desired output".
Generally, it is assumed, that efficiency can be quantified, e.g. by utilization rates, considerably more easily than effectiveness.
=== Quality ===
Tangen states: "Improvements in quality, other than the fact that no-fault products add to output levels, ought not to be included in the concept of productivity." However, most of the classic literature in non-software disciplines, especially in the manufacturing area, does not explicitly discuss the role of quality of the output in the productivity ratio. More recent works from non-manufacturing disciplines have a stronger focus on knowledge, office or white
|
https://en.wikipedia.org/wiki/Programming_productivity
|
ave a stronger focus on knowledge, office or white-collar work and hence increasingly discuss the role of quality with respect to quality.
Drucker stresses the importance of quality for the evaluation of knowledge worker productivity: "Productivity of knowledge work therefore has to aim first at obtaining quality—and not minimum quality but optimum if not maximum quality. Only then can one ask: "What is the volume, the quantity of work?""
Saari captures the importance of quality with his extended formula for productivity:
Total productivity = (Output quality and quantity)/(Input quality and quantity)
However, it appears that these efforts to include the quality in the determination of productivity did not lead to an operationalizable concept yet. It currently remains unclear how to quantify the vague terms “Output quality and quantity” as well as “Input quality and quantity”, let alone to calculate the ratio.
== State of the art ==
In software development things are more complicated
|
https://en.wikipedia.org/wiki/Programming_productivity
|
software development things are more complicated than in the production of goods. Software development is an engineering process.
=== COCOMO II ===
Boehm was one of the first researchers that systematically approached the field of software productivity. His cost estimation model COCOMO - now COCOMO II - is standard software engineering knowledge. In this model, he defines a set of factors that influence productivity, such as the required reliability or the capability of the analysts. These factors have been widely reused in other similar productivity approaches. The rest of the model is based on function points and finally source lines of code (LOC). The limitations of LOC as a productivity measure are well-known.
=== Jones's software productivity ===
Jones is the author of a series of books on software productivity. Besides several theoretical considerations his main contribution is the systematic provision and integration of a large amount of data relevant for productivity analy
|
https://en.wikipedia.org/wiki/Programming_productivity
|
rge amount of data relevant for productivity analyses. In at least two of his books, he gives a number of productivity factors but also points out that for each project a different set of factors are influential. These factors can form a basis for productivity assessments and for comparison with industrial averages.
This is one such list:
The 20 factors whose quantified impacts on software projects have been determined from historical data are the following:
Programming language used
Program size
The experience of programmers and design personnel
The novelty of requirements
The complexity of the program and its data
The use of structured programming methods
Program class or the distribution method
Program type of the application area
Tools and environmental conditions
Enhancing existing programs or systems
Maintaining existing programs or systems
Reusing existing modules and standard designs
Program generators
Fourth-generation languages
Geographic separation of development locations
|
https://en.wikipedia.org/wiki/Programming_productivity
|
es
Geographic separation of development locations
Defect potentials and removal methods
Existing documentation
Prototyping before main development begins
Project teams and organization structures
Morale and compensation of staff
=== Function points ===
Function points were proposed in 1977 by Albrecht as a better size measure for software than LOC. In that it is based on the specification of the software and thereby aims at measuring the size of its functionality rather than the code itself. The reason is that the size of the code not only depends on the size of the functionality but also on the capability of the programmer: better programmers will produce less code for the same functionality. The function points have undergone several redesigns over the years mainly driven by the International Function Point User Group (IFPUG). This group is large with over 1200 companies as member which shows the rather strong acceptance of this measure. However, in many domains it still lacks prac
|
https://en.wikipedia.org/wiki/Programming_productivity
|
sure. However, in many domains it still lacks practical application because it is often conceived as only applicable to business information systems.
=== Value-based software engineering ===
Several researchers proposed economic-driven or value-based software engineering as an important paradigm in future software engineering research. Boehm and Huang point out that is it not only important to track the costs in a software project but also the real earned value, i.e. the value for the customer. They explain that it is important to create the software business case and keep it up to date. In essence, value-based software engineering focuses on the customer value, mainly measured in monetary units.
=== Peopleware ===
The famous book Peopleware: Productive Projects and Teams by de Marco and Lister brought the importance of people-related factors to the attention of a broader audience. They collected in many software projects experiences with good and bad management practice that have
|
https://en.wikipedia.org/wiki/Programming_productivity
|
s with good and bad management practice that have an influence on the productivity of the team. They and others showed that these are the decisive issues in software engineering but were only able to describe them anecdotally.
== Factors influencing programming productivity ==
There are probably a large number of factors influencing the programming productivity of individuals and teams. For example, the used software development process probably influences the effectiveness and efficiency of a team.
The personalities of software programmers influence the used coding styles which, in turn, influence the productivity of the programmers.
== In popular culture ==
In 2007, the xkcd comic popularized the concept of a Ballmer Peak—that a programmer, with just the right amount of inebriation, achieves a high state of productivity. The Ballmer Peak is named after former Microsoft CEO, Steve Ballmer, and is likely a play on Balmer series of hydrogen spectral lines named for Johann Balmer.
|
https://en.wikipedia.org/wiki/Programming_productivity
|
ydrogen spectral lines named for Johann Balmer.
== References ==
== Further reading ==
Software Cost Estimation with Cocomo II, Barry W. Boehm et al., Prentice Hall, 2000. ISBN 978-0-13-026692-7.
Developing Products in Half the Time: New Rules, New Tools, Preston G. Smith and Donald G. Reinertsen, Wiley, 1997. ISBN 978-0-471-29252-4.
Programming Productivity, Capers Jones, Mcgraw-Hill, 1986. ISBN 978-0-07-032811-2.
Estimating Software Costs, Capers Jones, McGraw-Hill, 2007. ISBN 978-0-07-148300-1.
|
https://en.wikipedia.org/wiki/Programming_productivity
|
Egoless programming is a style of computer programming in which personal factors are minimized so that quality may be improved. The cooperative methods suggested are similar to those used by other collective ventures such as Wikipedia.
== History ==
The concept was first propounded by Gerald M. Weinberg in his 1971 book, The Psychology of Computer Programming.
== Peer reviews of code ==
To ensure quality, reviews of code by other programmers are made. The concept of egoless programming emphasises that such reviews should be made in a friendly, collegial way in which personal feelings are put aside. Structured walkthroughs are one way of making such a formal review.
== Strengths ==
Works best for complex tasks. ('difficult' used in )
Open communication channels allow information to flow freely to team members
Greater conformity that helps in consistent documentation
Team members have greater job satisfaction.
== Weaknesses ==
Projects take longer to complete.
Projects experie
|
https://en.wikipedia.org/wiki/Egoless_programming
|
Projects take longer to complete.
Projects experience a higher failure rate due to the decentralized nature of and volume of communication between members of the team.
Risky shift phenomenon – Programmers attempt riskier solutions to solve a software problem.
Simple tasks are made more difficult by open communication channels.
Note: The single paper cited for 'Strengths & Weaknesses' is from 1981 and says in its conclusions:
Most of the research on group problem-solving behavior was conducted in a laboratory setting with students and tasks of short duration.
None of these task/structure recommendations have been tested in a software development environment.
== Rival concepts ==
Egoless programming explicitly minimizes constraints of hierarchy and status so as to enable the free exchange of ideas and improvements. It may be contrasted with the chief programmer team concept which emphasises specialisation and leadership in teams so that they work in a more disciplined way.
== Se
|
https://en.wikipedia.org/wiki/Egoless_programming
|
that they work in a more disciplined way.
== See also ==
List of software development philosophies
Software review
Egolessness
== References ==
== External links ==
The Ten Commandments of Egoless Programming
|
https://en.wikipedia.org/wiki/Egoless_programming
|
In programming, a gotcha is a valid construct in a system, program or programming language that works as documented but is counter-intuitive and almost invites mistakes because it is both easy to invoke and unexpected or unreasonable in its outcome.
== Example ==
The classic gotcha in C/C++ is the construct
It is syntactically valid: it puts the value of b into a and then executes code if a is non-zero. Sometimes this is even intended. However most commonly it is a typo: the programmer probably meant
which executes code if a and b are equal. Modern compilers will usually generate a warning when encountering the former construct (conditional branch on assignment, not comparison), depending on compiler options (e.g., the -Wall option for gcc). To avoid this gotcha, some programming languages such include specific syntax for when this is desired behavior, such as Python's "walrus" operator (:=). In languages where this specific syntax does not exist, there is a recommendation to keep
|
https://en.wikipedia.org/wiki/Gotcha_(programming)
|
does not exist, there is a recommendation to keep the constants in the left side of the comparison, e.g. 42 == x rather than x == 42. This way, using = instead of == will cause a compiler error (see Yoda conditions). Many kinds of gotchas are not detected by compilers, however.
== See also ==
Usability
== References ==
== Further reading ==
Stephen C. Dewhurst (2003). C++ Gotchas (Avoiding Common Problems in Coding and Design). Addison-Wesley. ISBN 0321125185.
== External links ==
C Traps and Pitfalls by Andrew Koenig
C++ Gotchas A programmer's guide to avoiding and correcting ninety-nine of the most common, destructive, and interesting C++ design and programming errors, by Stephen C. Dewhurst
|
https://en.wikipedia.org/wiki/Gotcha_(programming)
|
In software engineering, "programming in the large" and "programming in the small" refer to two different aspects of writing software. "Programming in the large" means designing a larger system as a composition of smaller parts, and "programming in the small" means creating those smaller parts by writing lines of code in a programming language.
The terms were coined by Frank DeRemer and Hans Kron in their 1975 paper "Programming-in-the-large versus programming-in-the-small", in which they argue that the two are essentially different activities, and that typical programming languages, and the practice of structured programming, provide good support for the latter, but not for the former.
This may be compared to the later Ousterhout's dichotomy, which distinguishes between system programming languages (for components) and scripting languages (for glue code, connecting components).
== Description ==
Fred Brooks identifies that the way an individual program is created is different from h
|
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
|
individual program is created is different from how a programming systems product is created. The former likely does one relatively simple task well. It is probably coded by a single engineer, is complete in itself, and is ready to run on the system on which it was developed. The programming activity was probably fairly short-lived as simple tasks are quick and easy to complete. This is the endeavor that DeRemer and Kron describe as programming in the small.
Compare with the activities associated with a programming systems project, again as identified by Brooks. Such a project is typified by medium-sized or large industrial teams working on the project for many months to several years. The project is likely to be split up into several or hundreds of separate modules which individually are of a similar complexity to the individual programs described above. However, each module will define an interface to its surrounding modules.
Brooks describes how programming systems projects are typ
|
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
|
describes how programming systems projects are typically run as formal projects that follow industry best practices and will comprise testing, documentation and ongoing maintenance activities as well as activities to ensure that the product is generalized to work in different scenarios including on systems other than the development systems on which it was created.
== Programming in the large ==
In software development, programming in the large can involve programming by larger groups of people or by smaller groups over longer time periods. Either of these conditions will result in large, and hence complicated, programs that can be challenging for maintainers to understand.
With programming in the large, coding managers place emphasis on partitioning work into modules with precisely-specified interactions. This requires careful planning and documentation.
With programming in the large, program changes can become difficult. If a change operates across module boundaries, the work of ma
|
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
|
operates across module boundaries, the work of many people may need re-doing. Because of this, one goal of programming in the large involves setting up modules that will not need altering in the event of probable changes. This is achieved by designing modules so they have high cohesion and loose coupling.
Programming in the large requires management skills. The process of building abstractions aims not just to describe something that can work but also to direct the efforts of people who will make it work.
The concept was introduced by Frank DeRemer and Hans Kron in their 1975 paper "Programming-in-the-Large Versus Programming-in-the-Small", IEEE Trans. on Soft. Eng. 2(2).
In computer science terms, programming in the large can refer to programming code that represents the high-level state transition logic of a system. This logic encodes information such as when to wait for messages, when to send messages, when to compensate for failed non-ACID transactions, etc.
A language that was de
|
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
|
non-ACID transactions, etc.
A language that was designed to explicitly support programming in the large is BPEL.
== Programming in the small ==
In software development, programming in the small describes the activity of writing a small program. Small programs are typified by being small in terms of their source code size, are easy to specify, quick to code and typically perform one task or a few very closely related tasks very well.
Programming in the small can involve programming by individuals or small groups over short time periods and may involve less formal practices (for instance less emphasis on documentation or testing), tools and programming languages (e.g. the selection of a loosely typed scripting language in preference to a strictly typed programming language). Programming in the small can also describe an approach to building prototype software, or when rapid application development is more important than stability or correctness.
In computer science terms, programming i
|
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
|
rectness.
In computer science terms, programming in the small deals with short-lived programmatic behavior, often executed as a single ACID transaction and which allows access to local logic and resources such as files, databases, etc.
== References ==
== Further reading ==
DeRemer, Frank; Kron, Hans (1975). "Programming-in-the large versus programming-in-the-small". Proceedings of the international conference on Reliable software. Los Angeles, California: Association for Computing Machinery. pp. 114–121. doi:10.1145/800027.808431.
|
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
|
Comet is a web application model in which a long-held HTTPS request allows a web server to push data to a browser, without the browser explicitly requesting it. Comet is an umbrella term, encompassing multiple techniques for achieving this interaction. All these methods rely on features included by default in browsers, such as JavaScript, rather than on non-default plugins. The Comet approach differs from the original model of the web, in which a browser requests a complete web page at a time.
The use of Comet techniques in web development predates the use of the word Comet as a neologism for the collective techniques. Comet is known by several other names, including
Ajax Push,
Reverse Ajax, Two-way-web, HTTP Streaming, and
HTTP server push
among others. The term Comet is not an acronym, but was coined by Alex Russell in his 2006 blog post.
In recent years, the standardisation and widespread support of WebSocket and Server-sent events has rendered the Comet model obsolete.
== History
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
as rendered the Comet model obsolete.
== History ==
=== Early Java applets ===
The ability to embed Java applets into browsers (starting with Netscape Navigator 2.0 in March 1996) made two-way sustained communications possible, using a raw TCP socket to communicate between the browser and the server. This socket can remain open as long as the browser is at the document hosting the applet. Event notifications can be sent in any format – text or binary – and decoded by the applet.
=== The first browser-to-browser communication framework ===
The very first application using browser-to-browser communications was Tango Interactive, implemented in 1996–98 at the Northeast Parallel Architectures Center (NPAC) at Syracuse University using DARPA funding. TANGO architecture has been patented by Syracuse University. TANGO framework has been extensively used as a distance education tool. The framework has been commercialized by CollabWorx and used in a dozen or so Command&Control and Train
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
nd used in a dozen or so Command&Control and Training applications in the United States Department of Defense.
=== First Comet applications ===
The first set of Comet implementations dates back to 2000, with the Pushlets, Lightstreamer, and KnowNow projects. Pushlets, a framework created by Just van den Broecke, was one of the first open source implementations. Pushlets were based on server-side Java servlets, and a client-side JavaScript library. Bang Networks – a Silicon Valley start-up backed by Netscape co-founder Marc Andreessen – had a lavishly-financed attempt to create a real-time push standard for the entire web.
In April 2001, Chip Morningstar began developing a Java-based (J2SE) web server which used two HTTP sockets to keep open two communications channels between the custom HTTP server he designed and a client designed by Douglas Crockford; a functioning demo system existed as of June 2001. The server and client used a messaging format that the founders of State Softwa
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
messaging format that the founders of State Software, Inc. assented to coin as JSON following Crockford's suggestion. The entire system, the client libraries, the messaging format known as JSON and the server, became the State Application Framework, parts of which were sold and used by Sun Microsystems, Amazon.com, EDS and Volkswagen.
In March 2006, software engineer Alex Russell coined the term Comet in a post on his personal blog. The new term was a play on Ajax (Ajax and Comet both being common household cleaners in the USA).
In 2006, some applications exposed those techniques to a wider audience: Meebo’s multi-protocol web-based chat application enabled users to connect to AOL, Yahoo, and Microsoft chat platforms through the browser; Google added web-based chat to Gmail; JotSpot, a startup since acquired by Google, built Comet-based real-time collaborative document editing. New Comet variants were created, such as the Java-based ICEfaces JSF framework (although they prefer the term
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
faces JSF framework (although they prefer the term "Ajax Push"). Others that had previously used Java-applet based transports switched instead to pure-JavaScript implementations.
== Implementations ==
Comet applications attempt to eliminate the limitations of the page-by-page web model and traditional polling by offering two-way sustained interaction, using a persistent or long-lasting HTTP connection between the server and the client. Since browsers and proxies are not designed with server events in mind, several techniques to achieve this have been developed, each with different benefits and drawbacks. The biggest hurdle is the HTTP 1.1 specification, which states "this specification... encourages clients to be conservative when opening multiple connections". Therefore, holding one connection open for real-time events has a negative impact on browser usability: the browser may be blocked from sending a new request while waiting for the results of a previous request, e.g., a series
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
the results of a previous request, e.g., a series of images. This can be worked around by creating a distinct hostname for real-time information, which is an alias for the same physical server. This strategy is an application of domain sharding.
Specific methods of implementing Comet fall into two major categories: streaming and long polling.
=== Streaming ===
An application using streaming Comet opens a single persistent connection from the client browser to the server for all Comet events. These events are incrementally handled and interpreted on the client side every time the server sends a new event, with neither side closing the connection.
Specific techniques for accomplishing streaming Comet include the following:
==== Hidden iframe ====
A basic technique for dynamic web application is to use a hidden iframe HTML element (an inline frame, which allows a website to embed one HTML document inside another). This invisible iframe is sent as a chunked block, which implicitly dec
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
e is sent as a chunked block, which implicitly declares it as infinitely long (sometimes called "forever frame"). As events occur, the iframe is gradually filled with script tags, containing JavaScript to be executed in the browser. Because browsers render HTML pages incrementally, each script tag is executed as it is received. Some browsers require a specific minimum document size before parsing and execution is started, which can be obtained by initially sending 1–2 kB of padding spaces.
One benefit of the iframes method is that it works in every common browser. Two downsides of this technique are the lack of a reliable error handling method, and the impossibility of tracking the state of the request calling process.
==== XMLHttpRequest ====
The XMLHttpRequest (XHR) object, a tool used by Ajax applications for browser–server communication, can also be pressed into service for server–browser Comet messaging by generating a custom data format for an XHR response, and parsing out each
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
a format for an XHR response, and parsing out each event using browser-side JavaScript; relying only on the browser firing the onreadystatechange callback each time it receives new data.
=== Ajax with long polling ===
None of the above streaming transports work across all modern browsers without negative side-effects. This forces Comet developers to implement several complex streaming transports, switching between them depending on the browser. Consequently, many Comet applications use long polling, which is easier to implement on the browser side, and works, at minimum, in every browser that supports XHR. As the name suggests, long polling requires the client to poll the server for an event (or set of events). The browser makes an Ajax-style request to the server, which is kept open until the server has new data to send to the browser, which is sent to the browser in a complete response. The browser initiates a new long polling request in order to obtain subsequent events. IETF RFC
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
est in order to obtain subsequent events. IETF RFC 6202 "Known Issues and Best Practices for the Use of Long Polling and Streaming in Bidirectional HTTP" compares long polling and HTTP streaming.
Specific technologies for accomplishing long-polling include the following:
==== XMLHttpRequest long polling ====
For the most part, XMLHttpRequest long polling works like any standard use of XHR. The browser makes an asynchronous request of the server, which may wait for data to be available before responding. The response can contain encoded data (typically XML or JSON) or Javascript to be executed by the client. At the end of the processing of the response, the browser creates and sends another XHR, to await the next event. Thus the browser always keeps a request outstanding with the server, to be answered as each event occurs.
==== Script tag long polling ====
While any Comet transport can be made to work across subdomains, none of the above transports can be used across different seco
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
above transports can be used across different second-level domains (SLDs), due to browser security policies designed to prevent cross-site scripting attacks. That is, if the main web page is served from one SLD, and the Comet server is located at another SLD (which does not have cross-origin resource sharing enabled), Comet events cannot be used to modify the HTML and DOM of the main page, using those transports. This problem can be sidestepped by creating a proxy server in front of one or both sources, making them appear to originate from the same domain. However, this is often undesirable for complexity or performance reasons.
Unlike iframes or XMLHttpRequest objects, script tags can be pointed at any URI, and JavaScript code in the response will be executed in the current HTML document. This creates a potential security risk for both servers involved, though the risk to the data provider (in our case, the Comet server) can be avoided using JSONP.
A long-polling Comet transport can
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
d using JSONP.
A long-polling Comet transport can be created by dynamically creating script elements, and setting their source to the location of the Comet server, which then sends back JavaScript (or JSONP) with some event as its payload. Each time the script request is completed, the browser opens a new one, just as in the XHR long polling case. This method has the advantage of being cross-browser while still allowing cross-domain implementations.
== Alternatives ==
Browser-native technologies are inherent in the term Comet. Attempts to improve non-polling HTTP communication have come from multiple sides:
The HTML 5 specification produced by the Web Hypertext Application Technology Working Group (WHATWG) specifies so called server-sent events, which defines a new JavaScript interface EventSource and a new MIME type text/event-stream.
The HTML 5 WebSocket API working specifies a method for creating a persistent connection with a server and receiving messages via an onmessage callba
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
ver and receiving messages via an onmessage callback.
The Bayeux protocol by the Dojo Foundation. It leaves browser-specific transports in place, and defines a higher-level protocol for communication between browser and server, with the aim of allowing re-use of client-side JavaScript code with multiple Comet servers, and allowing the same Comet server to communicate with multiple client-side JavaScript implementations. Bayeux is based on a publish/subscribe model, so servers supporting Bayeux have publish/subscribe built-in.
The BOSH protocol by the XMPP standards foundation. It emulates a bidirectional stream between the browser and server by using two synchronous HTTP connections.
The JSONRequest object, proposed by Douglas Crockford, would be an alternative to the XHR object.
Use of plugins, such as Java applets or the proprietary Adobe Flash (using RTMP protocol for data streaming to Flash applications). These have the advantage of working identically across all browsers with the
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
working identically across all browsers with the appropriate plugin installed and need not rely on HTTP connections, but the disadvantage of requiring the plugin to be installed
Google announced a new Channel API for Google App Engine, implementing a Comet-like API with the help of a client JavaScript library on the browser. This API has been deprecated.
== See also ==
Push technology
Pull technology
== Notes ==
== References ==
== External links ==
"Comet Daily". Archived from the original on 2008-01-04. Retrieved 2007-11-29. Comet Daily provides information about Comet techniques.*
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
Block programming (also known as a strand in British broadcasting) is the arrangement of programs on radio or television so that those of a particular genre, theme, or target audience are united.
== Overview ==
Block programming involves scheduling a series of related shows which are likely to attract and hold a given audience for a long period of time. Notable examples of overt block programming were NBC's Thursday evening "Must See TV" lineup, which included two hours of sitcoms and one hour of ER, All TV's "Jeepney TV sa All TV" lineup, which consisting the replay of selected Filipino drama series produced by ABS-CBN Studios, a simulcast of ABS-CBN's daily morning talk show Magandang Buhay, and a simulcast of ABS-CBN News' afternoon newscast TV Patrol Express, and Channel 4's "T4" program which often ran sitcoms back-to-back for an hour or more. Reruns on cable television are often assembled into similar blocks to fill several hours of generally little-watched daytime periods. A p
|
https://en.wikipedia.org/wiki/Block_programming
|
s of generally little-watched daytime periods. A particularly long program block, especially one that does not air on a regular schedule, is known as a marathon.
Block programming in radio also refers to programming content that appeals to various demographics in time blocks, usually corresponding to the top or bottom of the hour or the quarter-hour periods. For example, various musical genres might be featured, such as a country music hour, a three-hour afternoon block of jazz, or a four-hour Saturday night '70s disco show.
Generally speaking, block programming is anathema to modern competitive commercial radio, which traditionally uses uniform formats, other than a handful of speciality shows in off-peak hours such as weekends (for instance, the infamous beaver hours in Canadian radio). The general rationale for not using block programming is that listeners expect a certain type of music when they tune into a radio station and breaking from that format will turn those listeners away
|
https://en.wikipedia.org/wiki/Block_programming
|
g from that format will turn those listeners away from the station; likewise, a station that airs its programming in hodgepodge blocks will have difficulty building listener loyalty, as listeners' music will only be on for a few hours of the day. This argument for homogenized radio was also a driving force behind the effective death of freeform radio in the late 20th century. The case of talk radio is indicative of the decline of block programming: prior to the 1980s, it was not uncommon to mix various blocks of talk programming together on one station, but this has declined dramatically in the late 1990s and beyond. A listener to a conservative talk radio station will have little interest in a progressive talk radio, sports radio or hot talk block, which reaches a different demographic; stations that have attempted the block strategy have historically been unsuccessful. Block programming of this nature is alive and well on outlets like public radio (such as NPR, the BBC, or CBC) and
|
https://en.wikipedia.org/wiki/Block_programming
|
public radio (such as NPR, the BBC, or CBC) and in multicultural radio serving broad ethnic and cultural audiences, although even in this realm the idea of block programming is declining due to competition for donations.
Some programming blocks have become so popular that they have been transformed to full-fledged 24-hour channels. Current channels which started as program blocks include Disney Jr. (which is still a program block on Disney Channel); the Nick Jr. Channel (based on the Nick Jr. block that still airs on Nickelodeon); Boomerang (which was once a program block on Cartoon Network); PBS Kids (which is still a program block on PBS) and MeTV Toons (which was once a programming block on MeTV). In addition, TV Land airs older shows that were once aired on sister channel Nickelodeon's Nick at Nite program block. Adult Swim is also a Cartoon Network programming block.
However, since the 2010s, new programming blocks have become rare due to airing programming in a regular format o
|
https://en.wikipedia.org/wiki/Block_programming
|
re due to airing programming in a regular format or with little or no brand reference within the programming block.
== See also ==
Audience flow
Lists of programming blocks
Strip programming
Broadcast programming
Dayparting
Marathon (media)
== References ==
|
https://en.wikipedia.org/wiki/Block_programming
|
Systems programming, or system programming, is the activity of programming computer system software. The primary distinguishing characteristic of systems programming when compared to application programming is that application programming aims to produce software which provides services to the user directly (e.g. word processor), whereas systems programming aims to produce software and software platforms which provide services to other software, are performance constrained, or both (e.g. operating systems, computational science applications, game engines, industrial automation, and software as a service applications).
Systems programming requires a great degree of hardware awareness. Its goal is to achieve efficient use of available resources, either because the software itself is performance-critical or because even small efficiency improvements directly transform into significant savings of time or money.
== Overview ==
The following attributes characterize systems programming:
Th
|
https://en.wikipedia.org/wiki/Systems_programming
|
g attributes characterize systems programming:
The programmer can make assumptions about the hardware and other properties of the system that the program runs on, and will often exploit those properties, for example by using an algorithm that is known to be efficient when used with specific hardware.
Usually a low-level programming language or programming language dialect is used so that:
Programs can operate in resource-constrained environments
Programs can be efficient with little runtime overhead, possibly having either a small runtime library or none at all
Programs may use direct and "raw" control over memory access and control flow
The programmer may write parts of the program directly in assembly language
Often systems programs cannot be run in a debugger. Running the program in a simulated environment can sometimes be used to reduce this problem.
In systems programming, often limited programming facilities are available. The use of automatic garbage collection is not common an
|
https://en.wikipedia.org/wiki/Systems_programming
|
e of automatic garbage collection is not common and debugging is sometimes hard to do. The runtime library, if available at all, is usually far less powerful, and does less error checking. Because of those limitations, monitoring and logging are often used; operating systems may have extremely elaborate logging subsystems.
Implementing certain parts in operating systems and networking requires systems programming, for example implementing paging (virtual memory) or a device driver for an operating system.
== History ==
Originally systems programmers invariably wrote in assembly language. Experiments with hardware support in high level languages in the late 1960s led to such languages as PL/S, BLISS, BCPL, and extended ALGOL for Burroughs large systems. Forth also has applications as a systems language.
In the 1970s, C became widespread, aided by the growth of Unix.
More recently a subset of C++ called Embedded C++ has seen some use, for instance it is used in the I/O Kit drivers of
|
https://en.wikipedia.org/wiki/Systems_programming
|
for instance it is used in the I/O Kit drivers of macOS.
Engineers working at Google created Go in 2007 to address developer productivity in large distributed systems, with developer-focused features such as Concurrency, Garbage Collection, and faster program compilation than C and C++.
In 2015 Rust came out, a general-purpose programming language often used in systems programming. Rust was designed with memory safety in mind and to be as performant as C and C++.
== Alternative meaning ==
For historical reasons, some organizations use the term systems programmer to describe a job function which would be more accurately termed systems administrator. This is particularly true in organizations whose computer resources have historically been dominated by mainframes, although the term is even used to describe job functions which do not involve mainframes. This usage arose because administration of IBM mainframes often involved the writing of custom assembler code (IBM's Basic Assembly La
|
https://en.wikipedia.org/wiki/Systems_programming
|
of custom assembler code (IBM's Basic Assembly Language (BAL)), which integrated with the operating system such as OS/MVS, DOS/VSE or VM/CMS. Indeed, some IBM software products had substantial code contributions from customer programming staff. This type of programming is progressively less common, and increasingly done in C rather than Assembly, but the term systems programmer is still used as the de-facto job title for staff administering IBM mainframes even in cases where they do not regularly engage in systems programming activities.
== See also ==
Ousterhout's dichotomy
System programming language
Scripting language
Interrupt handler
Computer Programming
== References ==
== Further reading ==
Systems Programming by John J. Donovan
|
https://en.wikipedia.org/wiki/Systems_programming
|
In computer programming, a parameter, a.k.a. formal argument, is a variable that represents an argument, a.k.a. actual argument, a.k.a. actual parameter, to a subroutine call.. A function's signature defines its parameters. A call invocation involves evaluating each argument expression of a call and associating the result with the corresponding parameter.
For example, consider subroutine def add(x, y): return x + y. Variables x and y are parameters. For call add(2, 3), the expressions 2 and 3 are arguments. For call add(a+1, b+2), the arguments are a+1 and b+2.
Parameter passing is defined by a programming language. Evaluation strategy defines the semantics for how parameters can be declared and how arguments are passed to a subroutine. Generally, with call by value, a parameter acts like a new, local variable initialized to the value of the argument. If the argument is a variable, the subroutine cannot modify the argument state because the parameter is a copy. With call by reference,
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
e the parameter is a copy. With call by reference, which requires the argument to be a variable, the parameter is an alias of the argument.
== Example ==
The following program defines a function named SalesTax with one parameter named price; both typed double.
For call SalesTax(10.00), the argument 10.00 is evaluated to a double value (10) and assigned to parameter variable price. The function is executed and returns the value 0.5.
== Parameters and arguments ==
The terms parameter and argument may have different meanings in different programming languages. Sometimes they are used interchangeably, and the context is used to distinguish the meaning. The term parameter (sometimes called formal parameter) is often used to refer to the variable as found in the function declaration, while argument (sometimes called actual parameter) refers to the actual input supplied at a function call statement. For example, if one defines a function as def f(x): ..., then x is the parameter, and i
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
n as def f(x): ..., then x is the parameter, and if it is called by a = ...; f(a) then a is the argument. A parameter is an (unbound) variable, while the argument can be a literal or variable or more complex expression involving literals and variables. In case of call by value, what is passed to the function is the value of the argument – for example, f(2) and a = 2; f(a) are equivalent calls – while in call by reference, with a variable as argument, what is passed is a reference to that variable - even though the syntax for the function call could stay the same. The specification for pass-by-reference or pass-by-value would be made in the function declaration and/or definition.
Parameters appear in procedure definitions; arguments appear in procedure calls. In the function definition f(x) = x*x the variable x is a parameter; in the function call f(2) the value 2 is the argument of the function. Loosely, a parameter is a type, and an argument is an instance.
A parameter is an intrinsic
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
gument is an instance.
A parameter is an intrinsic property of the procedure, included in its definition. For example, in many languages, a procedure to add two supplied integers together and calculate the sum would need two parameters, one for each integer. In general, a procedure may be defined with any number of parameters, or no parameters at all. If a procedure has parameters, the part of its definition that specifies the parameters is called its parameter list.
By contrast, the arguments are the expressions supplied to the procedure when it is called, usually one expression matching one of the parameters. Unlike the parameters, which form an unchanging part of the procedure's definition, the arguments may vary from call to call. Each time a procedure is called, the part of the procedure call that specifies the arguments is called the argument list.
Although parameters are also commonly referred to as arguments, arguments are sometimes thought of as the actual values or references
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
imes thought of as the actual values or references assigned to the parameter variables when the subroutine is called at run-time. When discussing code that is calling into a subroutine, any values or references passed into the subroutine are the arguments, and the place in the code where these values or references are given is the parameter list. When discussing the code inside the subroutine definition, the variables in the subroutine's parameter list are the parameters, while the values of the parameters at runtime are the arguments. For example, in C, when dealing with threads it is common to pass in an argument of type void* and cast it to an expected type:
To better understand the difference, consider the following function written in C:
The function Sum has two parameters, named addend1 and addend2. It adds the values passed into the parameters, and returns the result to the subroutine's caller (using a technique automatically supplied by the C compiler).
The code which calls t
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
upplied by the C compiler).
The code which calls the Sum function might look like this:
The variables value1 and value2 are initialized with values. value1 and value2 are both arguments to the sum function in this context.
At runtime, the values assigned to these variables are passed to the function Sum as arguments. In the Sum function, the parameters addend1 and addend2 are evaluated, yielding the arguments 40 and 2, respectively. The values of the arguments are added, and the result is returned to the caller, where it is assigned to the variable sum_value.
Because of the difference between parameters and arguments, it is possible to supply inappropriate arguments to a procedure. The call may supply too many or too few arguments; one or more of the arguments may be a wrong type; or arguments may be supplied in the wrong order. Any of these situations causes a mismatch between the parameter and argument lists, and the procedure will often return an unintended answer or generate a run
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
ften return an unintended answer or generate a runtime error.
=== Alternative convention in Eiffel ===
Within the Eiffel software development method and language, the terms argument and parameter have distinct uses established by convention. The term argument is used exclusively in reference to a routine's inputs, and the term parameter is used exclusively in type parameterization for generic classes.
Consider the following routine definition:
The routine sum takes two arguments addend1 and addend2, which are called the routine's formal arguments. A call to sum specifies actual arguments, as shown below with value1 and value2.
Parameters are also thought of as either formal or actual. Formal generic parameters are used in the definition of generic classes. In the example below, the class HASH_TABLE is declared as a generic class which has two formal generic parameters, G representing data of interest and K representing the hash key for the data:
When a class becomes a client to
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
y for the data:
When a class becomes a client to HASH_TABLE, the formal generic parameters are substituted with actual generic parameters in a generic derivation. In the following attribute declaration, my_dictionary is to be used as a character string based dictionary. As such, both data and key formal generic parameters are substituted with actual generic parameters of type STRING.
== Datatypes ==
In strongly typed programming languages, each parameter's type must be specified in the procedure declaration. Languages using type inference attempt to discover the types automatically from the function's body and usage. Dynamically typed programming languages defer type resolution until run-time. Weakly typed languages perform little to no type resolution, relying instead on the programmer for correctness.
Some languages use a special keyword (e.g. void) to indicate that the subroutine has no parameters; in formal type theory, such functions take an empty parameter list (whose type is
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
ctions take an empty parameter list (whose type is not void, but rather unit).
== Argument passing ==
The exact mechanism for assigning arguments to parameters, called argument passing, depends upon the evaluation strategy used for that parameter (typically call by value), which may be specified using keywords.
=== Default arguments ===
Some programming languages such as Ada, C++, Clojure, Common Lisp, Fortran 90, Python, Ruby, Tcl, and Windows PowerShell allow for a default argument to be explicitly or implicitly given in a subroutine's declaration. This allows the caller to omit that argument when calling the subroutine. If the default argument is explicitly given, then that value is used if it is not provided by the caller. If the default argument is implicit (sometimes by using a keyword such as Optional) then the language provides a well-known value (such as null, Empty, zero, an empty string, etc.) if a value is not provided by the caller.
PowerShell example:
Default argumen
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
y the caller.
PowerShell example:
Default arguments can be seen as a special case of the variable-length argument list.
=== Variable-length parameter lists ===
Some languages allow subroutines to be defined to accept a variable number of arguments. For such languages, the subroutines must iterate through the list of arguments.
PowerShell example:
=== Named parameters ===
Some programming languages—such as Ada and Windows PowerShell—allow subroutines to have named parameters. This allows the calling code to be more self-documenting. It also provides more flexibility to the caller, often allowing the order of the arguments to be changed, or for arguments to be omitted as needed.
PowerShell example:
=== Multiple parameters in functional languages ===
In lambda calculus, each function has exactly one parameter. What is thought of as functions with multiple parameters is usually represented in lambda calculus as a function which takes the first argument, and returns a function which
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
the first argument, and returns a function which takes the rest of the arguments; this is a transformation known as currying. Some programming languages, like ML and Haskell, follow this scheme. In these languages, every function has exactly one parameter, and what may look like the definition of a function of multiple parameters, is actually syntactic sugar for the definition of a function that returns a function, etc. Function application is left-associative in these languages as well as in lambda calculus, so what looks like an application of a function to multiple arguments is correctly evaluated as the function applied to the first argument, then the resulting function applied to the second argument, etc.
== Output parameters ==
An output parameter, also known as an out parameter or return parameter, is a parameter used for output, rather than the more usual use for input. Using call by reference parameters, or call by value parameters where the value is a reference, as output
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
ameters where the value is a reference, as output parameters is an idiom in some languages, notably C and C++, while other languages have built-in support for output parameters. Languages with built-in support for output parameters include Ada (see Ada subprograms), Fortran (since Fortran 90; see Fortran "intent"), various procedural extensions to SQL, such as PL/SQL (see PL/SQL functions) and Transact-SQL, C# and the .NET Framework, Swift, and the scripting language TScript (see TScript function declarations).
More precisely, one may distinguish three types of parameters or parameter modes: input parameters, output parameters, and input/output parameters; these are often denoted in, out, and in out or inout. An input argument (the argument to an input parameter) must be a value, such as an initialized variable or literal, and must not be redefined or assigned to; an output argument must be an assignable variable, but it need not be initialized, any existing value is not accessible, an
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
tialized, any existing value is not accessible, and must be assigned a value; and an input/output argument must be an initialized, assignable variable, and can optionally be assigned a value. The exact requirements and enforcement vary between languages – for example, in Ada 83 output parameters can only be assigned to, not read, even after assignment (this was removed in Ada 95 to remove the need for an auxiliary accumulator variable). These are analogous to the notion of a value in an expression being an r-value (has a value), an l-value (can be assigned), or an r-value/l-value (has a value and can be assigned), respectively, though these terms have specialized meanings in C.
In some cases only input and input/output are distinguished, with output being considered a specific use of input/output, and in other cases only input and output (but not input/output) are supported. The default mode varies between languages: in Fortran 90 input/output is default, while in C# and SQL extensions
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
/output is default, while in C# and SQL extensions input is default, and in TScript each parameter is explicitly specified as input or output.
Syntactically, parameter mode is generally indicated with a keyword in the function declaration, such as void f(out int x) in C#. Conventionally output parameters are often put at the end of the parameter list to clearly distinguish them, though this is not always followed. TScript uses a different approach, where in the function declaration input parameters are listed, then output parameters, separated by a colon (:) and there is no return type to the function itself, as in this function, which computes the size of a text fragment:
Parameter modes are a form of denotational semantics, stating the programmer's intent and allowing compilers to catch errors and apply optimizations – they do not necessarily imply operational semantics (how the parameter passing actually occurs). Notably, while input parameters can be implemented by call by value,
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
t parameters can be implemented by call by value, and output and input/output parameters by call by reference – and this is a straightforward way to implement these modes in languages without built-in support – this is not always how they are implemented. This distinction is discussed in detail in the Ada '83 Rationale, which emphasizes that the parameter mode is abstracted from which parameter passing mechanism (by reference or by copy) is actually implemented. For instance, while in C# input parameters (default, no keyword) are passed by value, and output and input/output parameters (out and ref) are passed by reference, in PL/SQL input parameters (IN) are passed by reference, and output and input/output parameters (OUT and IN OUT) are by default passed by value and the result copied back, but can be passed by reference by using the NOCOPY compiler hint.
A syntactically similar construction to output parameters is to assign the return value to a variable with the same name as the fun
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
value to a variable with the same name as the function. This is found in Pascal and Fortran 66 and Fortran 77, as in this Pascal example:
This is semantically different in that when called, the function is simply evaluated – it is not passed a variable from the calling scope to store the output in.
=== Use ===
The primary use of output parameters is to return multiple values from a function, while the use of input/output parameters is to modify state using parameter passing (rather than by shared environment, as in global variables). An important use of returning multiple values is to solve the semipredicate problem of returning both a value and an error status – see Semipredicate problem: Multivalued return.
For example, to return two variables from a function in C, one may write:
where x is an input parameter and width and height are output parameters.
A common use case in C and related languages is for exception handling, where a function places the return value in an output va
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
a function places the return value in an output variable, and returns a Boolean corresponding to whether the function succeeded or not. An archetypal example is the TryParse method in .NET, especially C#, which parses a string into an integer, returning true on success and false on failure. This has the following signature:
and may be used as follows:
Similar considerations apply to returning a value of one of several possible types, where the return value can specify the type and then value is stored in one of several output variables.
=== Drawbacks ===
Output parameters are often discouraged in modern programming, essentially as being awkward, confusing, and too low-level – commonplace return values are considerably easier to understand and work with. Notably, output parameters involve functions with side effects (modifying the output parameter) and are semantically similar to references, which are more confusing than pure functions and values, and the distinction between output
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
ns and values, and the distinction between output parameters and input/output parameters can be subtle. Further, since in common programming styles most parameters are simply input parameters, output parameters and input/output parameters are unusual and hence susceptible to misunderstanding.
Output and input/output parameters prevent function composition, since the output is stored in variables, rather than in the value of an expression. Thus one must initially declare a variable, and then each step of a chain of functions must be a separate statement. For example, in C++ the following function composition:
when written with output and input/output parameters instead becomes (for F it is an output parameter, for G an input/output parameter):
In the special case of a function with a single output or input/output parameter and no return value, function composition is possible if the output or input/output parameter (or in C/C++, its address) is also returned by the function, in which
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
dress) is also returned by the function, in which case the above becomes:
=== Alternatives ===
There are various alternatives to the use cases of output parameters.
For returning multiple values from a function, an alternative is to return a tuple. Syntactically this is clearer if automatic sequence unpacking and parallel assignment can be used, as in Go or Python, such as:
For returning a value of one of several types, a tagged union can be used instead; the most common cases are nullable types (option types), where the return value can be null to indicate failure. For exception handling, one can return a nullable type, or raise an exception. For example, in Python one might have either:
or, more idiomatically:
The micro-optimization of not requiring a local variable and copying the return when using output variables can also be applied to conventional functions and return values by sufficiently sophisticated compilers.
The usual alternative to output parameters in C and related
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
alternative to output parameters in C and related languages is to return a single data structure containing all return values. For example, given a structure encapsulating width and height, one can write:
In object-oriented languages, instead of using input/output parameters, one can often use call by sharing, passing a reference to an object and then mutating the object, though not changing which object the variable refers to.
== See also ==
Command-line argument
Evaluation strategy
Operator overloading
Free variables and bound variables
== Notes ==
== References ==
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
R is a programming language for statistical computing and data visualization. It has been adopted in the fields of data mining, bioinformatics and data analysis/data science.
The core R language is augmented by a large number of extension software packages, which contain reusable code, documentation, and sample data.
R software is open-source and free software. R is a GNU Project and licensed under the GNU General Public License. It is written primarily in C, Fortran, and R itself. Precompiled executables are provided for various operating systems.
As an interpreted language, R has a native command line interface. Moreover, multiple third-party graphical user interfaces are available, such as RStudio—an integrated development environment—and Jupyter—a notebook interface.
== History ==
R was started by professors Ross Ihaka and Robert Gentleman as a programming language to teach introductory statistics at the University of Auckland. The language was inspired by the S programming lang
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
he language was inspired by the S programming language, with most S programs able to run unaltered in R. The language was also inspired by Scheme's lexical scoping, allowing for local variables.
The name of the language, R, comes from being both an S language successor as well as the shared first letter of the authors, Ross and Robert. In August 1993, Ihaka and Gentleman posted a binary of R on StatLib — a data archive website. At the same time, they announced the posting on the s-news mailing list. On 5 December 1997, R became a GNU project when version 0.60 was released. On 29 February 2000, the 1.0 version was released.
== Packages ==
R packages are collections of functions, documentation, and data that expand R. For example, packages can add reporting features (using packages like RMarkdown, Quarto, knitr, and Sweave) and the capability to implement various statistical techniques (such as linear, generalized linear and nonlinear modeling, classical statistical tests, spatial ana
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
modeling, classical statistical tests, spatial analysis, time-series analysis, and clustering). Perceived easy package installation and usability have contributed to the language's adoption in data science.
Immediately available when starting R, base packages provide the basic and necessary syntax and commands for programming, computing, graphics production, basic arithmetic, and statistical functionality.
An example R package is the tidyverse package, which bundles several subsidiary packages to provide a common interface. It specializes in tasks related to accessing and processing "tidy data", which are data contained in a two-dimensional table with a single row for each observation and a single column for each variable.
Installing a package occurs only once. For example, to install the tidyverse package:
To load the functions, data, and documentation of a package, one executes the library() function. To load tidyverse:
The Comprehensive R Archive Network (CRAN) was founded in 1997
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
nsive R Archive Network (CRAN) was founded in 1997 by Kurt Hornik and Friedrich Leisch to host R's source code, executable files, documentation, and user-created packages. Its name and scope mimic the Comprehensive TeX Archive Network (CTAN) and the Comprehensive Perl Archive Network (CPAN). CRAN originally had three mirroring sites and twelve contributed packages. As of 16 October 2024, it has 99 mirrors and 21,513 contributed packages. Packages are also available on repositories like R-Forge, Omegahat, and GitHub.
On the CRAN web site as a form of guidance, Task Views lists packages on CRAN that are relevant for tasks related to a certain topics, such as causal inference, finance, genetics, high-performance computing, machine learning, medical imaging, meta-analysis, social sciences, and spatial statistics.
The Bioconductor project provides packages for genomic data analysis, complementary DNA, microarray, and high-throughput sequencing methods.
== Community ==
There are three main
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
ng methods.
== Community ==
There are three main groups that help support R software development:
The R Core Team was founded in 1997 to maintain the R source code.
The R Foundation for Statistical Computing was founded in April 2003 to provide financial support.
The R Consortium is a Linux Foundation project to develop R infrastructure.
The R Journal is an open access, academic journal which features short to medium-length articles on the use and development of R. It includes articles on packages, programming tips, CRAN news, and foundation news.
The R community hosts many conferences and in-person meetups. These groups include:
UseR!: an annual international R user conference (website)
Directions in Statistical Computing (DSC) (website)
R-Ladies: an organization to promote gender diversity in the R community (website)
SatRdays: R-focused conferences held on Saturdays (website)
R Conference (website)
posit::conf (formerly known as rstudio::conf) (website)
On social media sites lik
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
rstudio::conf) (website)
On social media sites like Twitter, the hashtag #rstats can be used to keep up with new developments in the R community.
== Examples ==
=== Hello, World! ===
"Hello, World!" program:
Alternatively:
=== Basic syntax ===
The following examples illustrate the basic syntax of the language and use of the command-line interface.
In R, the generally preferred assignment operator is an arrow made from two characters <-, although = can be used in some cases.
=== Structure of a function ===
R is able to create functions to add new functionality for reuse. Objects created within the body of the function (which are enclosed by curly brackets) remain only accessible from within the function, and any data type may be returned. In R, almost all functions and all user-defined functions are closures.
Example of creating a function to perform some arithmetic calculation:
Usage output:
It is possible to define functions to be used as infix operators with the special sy
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
to be used as infix operators with the special syntax `%name%` where "name" is the function variable name:
Since version 4.1.0 functions can be written in a short notation, which is useful for passing anonymous functions to higher-order functions:
=== Native pipe operator ===
In R version 4.1.0, a native pipe operator, |>, was introduced. This operator allows users to chain functions together one after another, instead of a nested function call.
Another alternative to nested functions, in contrast to using the pipe character, is using intermediate objects:
While the pipe operator can produce code that is easier to read, it has been advised to pipe together at most 10 to 15 lines and chunk code into sub-tasks which are saved into objects with meaningful names.
Here is an example with fewer than 10 lines that some readers may still struggle to grasp without intermediate named steps:
=== Object-oriented programming ===
The R language has native support for object-oriented progra
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
uage has native support for object-oriented programming. There are two native frameworks, the so-called S3 and S4 systems. The former, being more informal, supports single dispatch on the first argument and objects are assigned to a class by just setting a "class" attribute in each object. The latter is a Common Lisp Object System (CLOS)-like system of formal classes (also derived from S) and generic methods that supports multiple dispatch and multiple inheritance
In the example, summary is a generic function that dispatches to different methods depending on whether its argument is a numeric vector or a "factor":
=== Modeling and plotting ===
The R language has built-in support for data modeling and graphics. The following example shows how R can generate and plot a linear model with residuals.
Output:
=== Mandelbrot set ===
This Mandelbrot set example highlights the use of complex numbers. It models the first 20 iterations of the equation z = z2 + c, where c represents differen
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
e equation z = z2 + c, where c represents different complex constants.
Install the package that provides the write.gif() function beforehand:
R Source code:
== Version names ==
All R version releases from 2.14.0 onward have codenames that make reference to Peanuts comics and films.
In 2018, core R developer Peter Dalgaard presented a history of R releases since 1997. Some notable early releases before the named releases include:
Version 1.0.0 released on 29 February 2000 (2000-02-29), a leap day
Version 2.0.0 released on 4 October 2004 (2004-10-04), "which at least had a nice ring to it"
The idea of naming R version releases was inspired by the Debian and Ubuntu version naming system. Dalgaard also noted that another reason for the use of Peanuts references for R codenames is because, "everyone in statistics is a P-nut".
== Interfaces ==
R comes installed with a command line console, but it is not the only way to interface with R.
By integrated development environment (IDE):
R.
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
.
By integrated development environment (IDE):
R.app (OSX/macOS only)
Rattle GUI
R Commander
RKWard
RStudio
Tinn-R
By general purpose IDEs:
Eclipse via the StatET plugin
Visual Studio via R Tools for Visual Studio.
By source-code editors:
Emacs
Vim via the Nvim-R plugin
Kate
LyX via Sweave
WinEdt (website)
Jupyter (website)
By other scripting languages:
Python (website)
Perl (website)
Ruby (source code)
F# (website)
Julia (source code).
By general purpose programming languages:
Java via the Rserve socket server
.NET C# (website)
Statistical frameworks which use R in the background include Jamovi and JASP.
== Implementations ==
The main R implementation is written primarily in C, Fortran, and R itself. Other implementations include:
pretty quick R (pqR), by Radford M. Neal, attempts to improve memory management.
Renjin is an implementation of R for the Java Virtual Machine.
CXXR and Riposte are implementations of R written in C++.
Oracle's FastR is an implementation of R, built on G
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
acle's FastR is an implementation of R, built on GraalVM.
TIBCO Software, creator of S-PLUS, wrote TERR — an R implementation to integrate with Spotfire.
Microsoft R Open (MRO) was an R implementation. As of 30 June 2021, Microsoft started to phase out MRO in favor of the CRAN distribution.
== Commercial support ==
Although R is an open-source project, some companies provide commercial support:
Oracle provides commercial support for the Big Data Appliance, which integrates R into its other products.
IBM provides commercial support for in-Hadoop execution of R.
== See also ==
Comparison of numerical-analysis software
Comparison of statistical packages
List of numerical-analysis software
List of statistical software
Rmetrics
== Notes ==
== References ==
== Further reading ==
Wickham, Hadley; Çetinkaya-Rundel, Mine; Grolemund, Garrett (2023). R for data science: import, tidy, transform, visualize, and model data (2nd ed.). Beijing Boston Farnham Sebastopol Tokyo: O'Reilly. IS
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
jing Boston Farnham Sebastopol Tokyo: O'Reilly. ISBN 978-1-4920-9740-2.
Gagolewski, Marek (2024). Deep R Programming. doi:10.5281/ZENODO.7490464. ISBN 978-0-6455719-2-9.
== External links ==
R Technical Papers
Big Book of R, curated list of R-related programming books
Books Related to R - R Project, partially annotated curated list of books relating to R or S.
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
Parametric programming is a type of mathematical optimization, where the optimization problem is solved as a function of one or multiple parameters. Developed in parallel to sensitivity analysis, its earliest mention can be found in a thesis from 1952. Since then, there have been considerable developments for the cases of multiple parameters, presence of integer variables as well as nonlinearities.
== Notation ==
In general, the following optimization problem is considered
J
∗
(
θ
)
=
min
x
∈
R
|
https://en.wikipedia.org/wiki/Parametric_programming
|
n
f
(
x
,
θ
)
subject to
g
(
x
,
θ
)
≤
0.
θ
∈
Θ
⊂
R
m
{\displaystyle {\begin{aligned}J^{*}(\theta )=&\min _{x\in \mathbb {R} ^{n}}f(x,\theta )\\&{\text{s
|
https://en.wikipedia.org/wiki/Parametric_programming
|
in _{x\in \mathbb {R} ^{n}}f(x,\theta )\\&{\text{subject to }}g(x,\theta )\leq 0.\\&\theta \in \Theta \subset \mathbb {R} ^{m}\end{aligned}}}
where
x
{\displaystyle x}
is the optimization variable,
θ
{\displaystyle \theta }
are the parameters,
f
(
x
,
θ
)
{\displaystyle f(x,\theta )}
is the objective function and
g
(
x
,
θ
)
{\displaystyle g(x,\theta )}
denote the constraints.
J
∗
{\displaystyle J^{*}}
denotes a function whose output is the optimal value of the objective function
f
{\displaystyle f}
. The set
Θ
{\displaystyle \Theta }
is generally r
|
https://en.wikipedia.org/wiki/Parametric_programming
|
{\displaystyle \Theta }
is generally referred to as parameter space.
The optimal value (i.e. result of solving the optimization problem) is obtained by evaluating the function with an argument
θ
{\displaystyle \theta }
.
== Classification ==
Depending on the nature of
f
(
x
,
θ
)
{\displaystyle f(x,\theta )}
and
g
(
x
,
θ
)
{\displaystyle g(x,\theta )}
and whether the optimization problem features integer variables, parametric programming problems are classified into different sub-classes:
If more than one parameter is present, i.e.
m
>
1
{\displaystyle m>1}
, then it is often referred to as multiparametric programming problem
If integer variables are present, then the problem is referred to as (multi)para
|
https://en.wikipedia.org/wiki/Parametric_programming
|
nt, then the problem is referred to as (multi)parametric mixed-integer programming problem
If constraints are affine, then additional classifications depending to nature of the objective function in (multi)parametric (mixed-integer) linear, quadratic and nonlinear programming problems is performed. Note that this generally assumes the constraints to be affine.
== Applications ==
=== In control theory generally and in process industries ===
The connection between parametric programming and model predictive control for process manufacturing, established in 2000, has contributed to an increased interest in the topic. Parametric programming supplies the idea that optimization problems can be parametrized as functions that can be evaluated (similar to a lookup table). This in turns allows the optimization algorithms in optimal controllers to be implemented as pre-computed (off-line) mathematical functions, which may in some cases be simpler and faster to evaluate than solving a full opt
|
https://en.wikipedia.org/wiki/Parametric_programming
|
ler and faster to evaluate than solving a full optimization problem on-line. This also opens up the possibility of creating optimal controllers on chips (MPC on chip). However, the off-line parametrization of optimal solutions runs into the curse of dimensionality as the number of possible solutions grows with the dimensionality and number of constraints in the problem.
=== In CNC programming ===
Parametric programming in the context of CNC (computer numerical control) is defining part-cutting cycles in terms of variables with reassignable values rather than via hardcoded/hardwired instances. An archetypically simple example is writing a G-code program to machine a family of washers: there is often no need to write 15 programs for 15 members of the family with various hole diameters, outer diameters, thicknesses, and materials, when it is practical instead to write 1 program that calls various variables and reads their current values from a table of assignments. The program then inst
|
https://en.wikipedia.org/wiki/Parametric_programming
|
from a table of assignments. The program then instructs the machine slides and spindles to move to various positions at various velocities, accordingly, addressing not only the sizes of the part (i.e., OD, ID, thickness) but also even the speeds and feeds needed for any given material (e.g., low-carbon steel, high-carbon steel; stainless steel of whichever grade; bronze, brass, or aluminum of whichever grade; polymer of whichever type). Custom Macros are often used in such programming.
== References ==
|
https://en.wikipedia.org/wiki/Parametric_programming
|
An esoteric programming language (sometimes shortened to esolang) is a programming language designed to test the boundaries of computer programming language design, as a proof of concept, as software art, as a hacking interface to another language (particularly functional programming or procedural programming languages), or as a joke. The use of the word esoteric distinguishes them from languages that working developers use to write software. The creators of most esolangs do not intend them to be used for mainstream programming, although some esoteric features, such as visuospatial syntax, have inspired practical applications in the arts. Such languages are often popular among hackers and hobbyists.
Usability is rarely a goal for designers of esoteric programming languages; often their design leads to quite the opposite. Their usual aim is to remove or replace conventional language features while still maintaining a language that is Turing-complete, or even one for which the computatio
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
ing-complete, or even one for which the computational class is unknown.
== History ==
The earliest, and still the canonical example of an esoteric programming language, is INTERCAL, designed in 1972 by Don Woods and James M. Lyon, who said that their intention was to create a programming language unlike any with which they were familiar. It parodied elements of established programming languages of the day such as Fortran, COBOL and assembly language.
For many years, INTERCAL was represented only by paper copies of the INTERCAL manual. Its revival in 1990 as an implementation in C under Unix stimulated a wave of interest in the intentional design of esoteric computer languages.
In 1993, Wouter van Oortmerssen created FALSE, a small stack-oriented programming language with syntax designed to make the code inherently obfuscated, confusing and unreadable. Its compiler is only 1024 bytes in size. This inspired Urban Müller to create an even smaller language, the now-infamous Brainfuck,
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
ven smaller language, the now-infamous Brainfuck, which consists of only eight recognized characters. Along with Chris Pressey's Befunge (like FALSE, but with a two-dimensional instruction pointer), Brainfuck is now one of the best-supported esoteric programming languages, with canonical examples of minimal Turing tarpits and needlessly obfuscated language features. Brainfuck is related to the P′′ family of Turing machines.
== Common features ==
While esoteric programming languages differ in many ways, there are some common traits that characterize many languages, such as parody, minimalism, and the goal of making programming difficult. Many esoteric programming languages, such as brainfuck, and similar, use single characters as commands, however, it is not uncommon for languages to read line by line like conventional programming languages.
=== Unique data representations ===
Conventional imperative programming languages typically allow data to be stored in variables, but esoteric
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
llow data to be stored in variables, but esoteric languages may utilize different methods of storing and accessing data. Languages like Brainfuck and Malbolge only permit data to be read through a single pointer, which must be moved to a location of interest before data is read. Others, like Befunge and Shakespeare, utilize one or more stacks to hold data, leading to a manner of execution akin to Reverse Polish notation. Finally, there are languages which explore alternative forms of number representation: the Brainfuck variant Boolfuck only permits operations on single bits, while Malbolge and INTERCAL variant TriINTERCAL replace bits altogether with a base 3 ternary system.
=== Unique instruction representations ===
Esoteric languages also showcase unique ways of representing program instructions. Some languages, such as Befunge and Piet, represent programs in two or more dimensions, with program control moving around in multiple possible directions through the program. This differ
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
ssible directions through the program. This differs from conventional languages in which a program is a set of instructions usually encountered in sequence. Other languages modify instructions to appear in an unusual form, often one that can be read by humans with an alternate meaning to the underlying instructions. Shakespeare achieves this by making all programs resemble Shakespearian plays. Chef achieves the same by having all programs be recipes. Chef is particularly notable in that some have created programs that successfully function both as a program and as a recipe, demonstrating the ability of the language to produce this double meaning.
=== Difficulty to read and write ===
Many esoteric programming languages are designed to produce code that is deeply obfuscated, making it difficult to read and to write. The purpose of this may be to provide an interesting puzzle or challenge for program writers: Malbolge for instance was explicitly designed to be challenging, and so it has
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
plicitly designed to be challenging, and so it has features like self-modifying code and highly counterintuitive operations. On the other hand, some esoteric languages become difficult to write due to their other design choices. Brainfuck is committed to the idea of a minimalist instruction set, so even though its instructions are straightforward in principle, the code that arises is difficult for a human to read. INTERCAL's difficulty arises as a result of the choice to avoid operations used in any other programming language, which stems from its origin as a parody of other languages.
=== Parody and spoof ===
One of the aims of esoteric programming languages is to parody or spoof existing languages and trends in the field of programming. For instance, the first esoteric language INTERCAL began as a spoof of languages used in the 1960s, such as APL, Fortran, and COBOL. INTERCAL's rules appear to be the inverse of rules in these other languages. However, the subject of parody is not a
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
languages. However, the subject of parody is not always another established programming language. Shakespeare can be viewed as spoofing the structure of Shakespearean plays, for instance. The language Ook! is a parody of Brainfuck, where Brainfuck's eight commands are replaced by various orangutan sounds like "Ook. Ook?"
== Examples ==
=== Befunge ===
Befunge allows the instruction pointer to roam in multiple dimensions through the code. For example, the following program displays "Hello World" by pushing the characters in reverse order onto the stack, then printing the characters in a loop which circulates clockwise through the instructions >, :, v, _, ,, and ^.
There are many versions of Befunge, the most common being Befunge-93, named as such because of its release year.
=== Binary lambda calculus ===
Binary lambda calculus is designed from an algorithmic information theory perspective to allow for the densest possible code with the most minimal means, featuring a 29-byte sel
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
th the most minimal means, featuring a 29-byte self interpreter, a 21-byte prime number sieve, and a 112-byte Brainfuck interpreter.
=== Brainfuck ===
Brainfuck is designed for extreme minimalism and leads to obfuscated code, with programs containing only eight distinct characters. The following program outputs "Hello, world!":
All characters other than +-<>,.[] are ignored.
=== Chicken ===
Chicken has just three tokens, the word "chicken", " " (the space character), and the newline character. The compiler interprets the number of "chickens" on a line as an opcode instruction which it uses to manipulate data on a stack. A simple chicken program can contain dozens of lines with nothing but the word "chicken" repeated countless times. Chicken was invented by Torbjörn Söderstedt who drew his inspiration for the language from a parody of a scientific dissertation.
=== Chef ===
Chef is a stack-oriented programming language created by David Morgan-Mar, designed to make programs look l
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
David Morgan-Mar, designed to make programs look like cooking recipes. Programs consist of a title, a list of variables and their data values, and a list of stack manipulation instructions. A joking design principle states that "program recipes should not only generate valid output, but be easy to prepare and delicious", and Morgan-Mar notes that an example "Hello, World!" program with 101 eggs and 111 cups (~26,640 mL) oil would produce "a lot of food for one person."
=== FRACTRAN ===
A FRACTRAN program is an ordered list of positive fractions together with an initial positive integer input
n
{\displaystyle n}
. The program is run by multiplying the integer
n
{\displaystyle n}
by the first fraction
f
{\displaystyle f}
in the list for which
n
f
{\displaystyle nf}
is an integer. The integer
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
nf}
is an integer. The integer
n
{\displaystyle n}
is then replaced by
n
f
{\displaystyle nf}
and the rule is repeated. If no fraction in the list produces an integer when multiplied by
n
{\displaystyle n}
, the program halts. FRACTRAN was invented by mathematician John Conway.
=== GolfScript ===
Programs in GolfScript, a language created for code golf, consist of lists of items, each of which is pushed onto the stack as it is encountered, with the exception of variables which have code blocks as their value, in which case the code is executed.
=== INTERCAL ===
INTERCAL, short for "Compiler Language With No Pronounceable Acronym", was created in 1972 as a parody to satirize aspects of the various programming languages at the time.
=== JSFuck ===
JSFuck is an esoteric programming style of JavaScript, where code is written using only six ch
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
avaScript, where code is written using only six characters: [, ], (, ), !, and +.
Unlike Brainfuck, which requires its own compiler or interpreter, JSFuck is valid JavaScript code, meaning JSFuck programs can be run in any web browser or engine that interprets JavaScript. It has been used in a number of cross-site scripting (XSS) attacks on websites such as eBay due to its ability to evade cross-site scripting detection filters.
=== LOLCODE ===
LOLCODE is designed to resemble the speech of lolcats. The following is the "Hello World" example:
HAI
CAN HAS STDIO?
VISIBLE "HAI WORLD!"
KTHXBYE
While the semantics of LOLCODE is not unusual, its syntax has been described as a linguistic phenomenon, representing an unusual example of informal speech and internet slang in programming.
=== Malbolge ===
Malbolge (named after the 8th circle of Hell) was designed to be the most difficult and esoteric programming language. Among other features, code is self-modifying by design and the effect
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
, code is self-modifying by design and the effect of an instruction depends on its address in memory.
=== Piet ===
Piet is a language designed by David Morgan-Mar, whose programs are bitmaps that look like abstract art. The execution is guided by a "pointer" that moves around the image, from one continuous coloured region to the next. Procedures are carried out when the pointer exits a region.
There are 20 colours for which behaviour is specified: 18 "colourful" colours, which are ordered by a 6-step hue cycle and a 3-step brightness cycle; and black and white, which are not ordered. When exiting a "colourful" colour and entering another one, the performed procedure is determined by the number of steps of change in hue and brightness. Black cannot be entered; when the pointer tries to enter a black region, the rules of choosing the next block are changed instead. If all possible rules are tried, the program terminates. Regions outside the borders of the image are also treated as bla
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
e the borders of the image are also treated as black. White does not perform operations, but allows the pointer to "pass through". The behaviour of colours other than the 20 specified is left to the compiler or interpreter.
Variables are stored in memory as signed integers in a single stack. Most specified procedures deal with operations on that stack, while others deal with input/output and with the rules by which the compilation pointer moves.
Piet was named after the Dutch painter Piet Mondrian. The original intended name, Mondrian, was already taken by an open-source statistical data-visualization system.
=== Shakespeare ===
Shakespeare Programming Language (SPL) is designed to make programs look like Shakespearean plays. For example, the following statement declares a point in the program which can be reached via a GOTO-type statement:
Act I: Hamlet's insults and flattery.
=== Unlambda ===
Unlambda is a minimalist functional programming language based on SKI calculus, but co
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
programming language based on SKI calculus, but combined with first-class continuations and imperative I/O (with input usually requiring the use of continuations).
=== Whitespace ===
Whitespace uses only whitespace characters (space, tab, and return), ignoring all other characters, which can therefore be used for comments. This is the reverse of many traditional languages, which do not distinguish between different whitespace characters, treating tab and space the same. It also allows Whitespace programs to be hidden in the source code of programs in languages like C.
== Cultural context ==
The cultural context of esolangs has been studied by Geoff Cox, who writes that esolangs "shift attention from command and control toward cultural expression and refusal", seeing esolangs as similar to code art and code poetry, such as Mez Breeze's mezangelle, a belief shared by others in field. Daniel Temkin describes Brainfuck as "refusing to ease the boundary between human expression and ass
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
ease the boundary between human expression and assembly code and thereby taking us on a ludicrous journey of logic," exposing the inherent conflict between human thinking and computer logic by deconstructing their relationship. He connects programming within an esolang to performing an event score such as those of the Fluxus movement, where playing out the irregular rules of the logic in code makes the point of view of the language clear.
== References ==
== Bibliography ==
Paloque-Bergès, Camille (2009). "Langages ésotériques". Poétique des codes sur le réseau informatique. Archives contemporaines. ISBN 978-2-914610-70-4.
Cox, Geoff (2013). Speaking Code: Coding as Aesthetic and Political Expression. MIT Press. ISBN 978-0-262-01836-4.
Kneusel, Ronald (2022). Strange Code: Esoteric Languages That Make Programming Fun Again. No Starch Press. ISBN 978-1718502406.
== External links ==
Esolang, the esoteric programming languages wiki
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
A programmer, computer programmer or coder is an author of computer source code – someone with skill in computer programming.
The professional titles software developer and software engineer are used for jobs that require a programmer.
== Identification ==
Sometimes a programmer or job position is identified by the language used or target platform. For example, assembly programmer, web developer.
== Job title ==
The job titles that include programming tasks have differing connotations across the computer industry and to different individuals. The following are notable descriptions.
A software developer primarily implements software based on specifications and fixes bugs. Other duties may include reviewing code changes and testing.
To achieve the required skills for the job, they might obtain a computer science or associate degree, attend a programming boot camp or be self-taught.
A software engineer usually is responsible for the same tasks as a developer
plus broader responsibili
|
https://en.wikipedia.org/wiki/Programmer
|
ame tasks as a developer
plus broader responsibilities of software engineering including architecting and designing new features and applications, targeting new platforms, managing the software development lifecycle (design, implementation, testing, and deployment), leading a team of programmers, communicating with customers, managers and other engineers, considering system stability and quality, and exploring software development methodologies.
Sometimes, a software engineer is required to have a degree in software engineering, computer engineering, or computer science. Some countries legally require an engineering degree to be called engineer.
== History ==
British countess and mathematician Ada Lovelace is often considered to be the first computer programmer.
She authored an algorithm, which was published in October 1842, for calculating Bernoulli numbers on the Charles Babbage analytical engine.
Because the machine was not completed in her lifetime, she never experienced the a
|
https://en.wikipedia.org/wiki/Programmer
|
leted in her lifetime, she never experienced the algorithm in action.
In 1941, German civil engineer Konrad Zuse was the first person to execute a program on a working, program-controlled, electronic computer. From 1943 to 1945, per computer scientist Wolfgang K. Giloi and AI professor Raúl Rojas et al., Zuse created the first, high-level programming language, Plankalkül.
Members of the 1945 ENIAC programming team of Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Wescoff, Fran Bilas and Ruth Lichterman have since been credited as the first professional computer programmers.
== The software industry ==
The first company founded specifically to provide software products and services was the Computer Usage Company in 1955. Before that time, computers were programmed either by customers or the few commercial computer manufacturers of the time, such as Sperry Rand and IBM.
The software industry expanded in the early 1960s, almost immediately after computers were first sold in mass-pro
|
https://en.wikipedia.org/wiki/Programmer
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.