Wikiszótár huwiktionary https://hu.wiktionary.org/wiki/Wikisz%C3%B3t%C3%A1r:Kezd%C5%91lap MediaWiki 1.47.0-wmf.10 case-sensitive Média Speciális Vita Szerkesztő Szerkesztővita Wikiszótár Wikiszótár-vita Fájl Fájlvita MediaWiki MediaWiki-vita Sablon Sablonvita Segítség Segítségvita Kategória Kategóriavita Függelék Függelékvita Index Indexvita TimedText TimedText talk Modul Modulvita Event Event talk 0 22845 3523814 3508902 2026-07-10T19:51:15Z Neriassel 28746 lap visszaállítása szótárcikk szintre 3523814 wikitext text/x-wiki {{engfn}} # {{label|en|informatika}} [[tudós]] {{engl}} iy9mspe0j0ykefcamebjordoxknmd3n 0 25614 3523818 3483173 2026-07-11T06:10:40Z ~2026-39071-10 34607 Visszavontam [[Special:Contributions/LinguisticMystic|LinguisticMystic]] ([[User talk:LinguisticMystic|vita]]) szerkesztését (oldid: [[Special:Diff/3483173|3483173]]) 3523818 wikitext text/x-wiki {{ru-noun-table|b|ого́нь|m*}} {{rusm}} # [[tűz]] # [[lámpafény]], [[világítás]], [[fény]] # [[hév]], [[lelkesedés]] #: {{uxi|ru| глаза горят огнём | szeme tűzben ég}} #: {{uxi|ru| заградительный огонь | zárótűz}} #: {{uxi|ru| зажечь огонь | világosságot gyújt}} #: {{uxi|ru| линия огня | tűzvonal}} #: {{uxi|ru| меж двух огней | két tűz között}} #: {{uxi|ru| нет дыма без огня | nem zörög a haraszt, ha a szél nem fújja [tkp. füst nincsen tűz nélkül]}} #: {{uxi|ru| огнём и мечом | tűzzel-vassal}} #: {{uxi|ru| перекрёстный огонь | kereszttűz}} #: {{uxi|ru| подливать масла в огонь | olajat önt a tűzre}} #: {{uxi|ru| попасть из огня да в полымя | csöbörből vödörbe [tkp. a tűzből a lángba]}} #: {{uxi|ru| работать при огне | lámpafénynél dolgozik}} #: {{uxi|ru| развести огонь | tüzet rak}} ---- {{orosz500}} {{rusl}} 0hlitkvan6orxjneujuyqph4do7pjza 0 112034 3523812 3496358 2026-07-10T19:49:33Z Neriassel 28746 lap visszaállítása szótárcikk szintre 3523812 wikitext text/x-wiki {{hunfn|fej=[[operációs]] [[rendszer]]}} # {{informatika|lang=hu}} A számítástechnikában a [[számítógép]]eknek az az alapprogramja, amely közvetlenül kezeli a hardvert, és egy egységes környezetet biztosít a számítógépen futtatandó [[alkalmazás]]oknak. {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|operating system}} *{{eo}}: {{t|eo|mastruma sistemo}} *{{fr}}: {{t+|fr|système d'exploitation|m}} *{{pl}}: {{t+|pl|system operacyjny|m}} {{trans-mid}} *{{de}}: {{t+|de|Betriebssystem|n}} *{{ru}}: {{t+|ru|операционная система|f}} *{{ro}}: {{t|ro|sistem de operare|}} *{{sv}}: {{t+|sv|operativsystem|n}} *{{uk}}: {{t|uk|операці́йна систе́ма|f}} {{trans-bottom}} {{hunl}} onb0i9v4wmffdl7584z98cg1e3vdbjw 0 128983 3523816 3486819 2026-07-10T19:52:40Z Neriassel 28746 lap visszaállítása szótárcikk szintre 3523816 wikitext text/x-wiki {{rusGeo}} {{ru-proper noun+|[[соединённый|Соединённые]]|+|_|[[штат|Шта́ты]]|m|_|[[Америка|Аме́рики]]|$}} #[[Amerikai Egyesült Államok]] {{rusl}} j21elvxl722n5zabkmvv3lxsw7qjp3r 0 187726 3523815 3500421 2026-07-10T19:52:04Z Neriassel 28746 lap visszaállítása szótárcikk szintre 3523815 wikitext text/x-wiki {{hunfn|fej=[[mesterséges]] [[intelligencia]]}} # {{label|hu|informatika}} {{-ford-}} {{trans-top}} *{{en}}: {{t|en|artificial intelligence}} *{{ar}}: {{t|ar|ذكاء اصطناعي|m|tr=dhaka'a iStinaa`ayy}} *{{cs}}: {{t-|cs|umělá inteligence|f}} *{{fi}}: {{t-|fi|keinoäly}}, {{t-|fi|tekoäly}} *{{el}}: {{t+|el|τεχνητή νοημοσύνη|f|tr=technití noimosýni}} *{{he}}: {{t|he|הבינה מלאכותית}} *{{nl}}: [[kunstmatige intelligentie]] {{g|f}} *{{ja}}: {{t-|ja|人工知能|tr=じんこうちのう, jinkō chinō}}, {{t|ja|アーティフィシャルインテリジェンス|tr=ātifisharuinterijensu}} *{{zh}}: {{t|cmn|人工智能|tr=réngōng zhìnéng}} {{trans-mid}} *{{pl}}: {{t|pl|sztuczna inteligencja|f}} *{{mk}}: {{t|mk|вештачка интелигенција|f|tr=véštačka inteligéncija}} *{{de}}: {{t-|de|künstliche Intelligenz}} *{{it}}: {{t-|it|intelligenza artificiale}} *{{ru}}: {{t|ru|искусственный интеллект|m|tr=iskússtvennyj intellékt}} *{{pt}}: [[inteligência artificial]] *{{ro}}: {{t|ro|inteligență artificială}} *{{es}}: [[inteligencia artificial]] *{{sv}}: {{t-|sv|artificiell intelligens|c}} *{{uk}}: {{t|uk|шту́чний інтеле́кт|m}} {{trans-bottom}} {{hunl}} d2zmcl3f3cfmhl94fw6wd7a9ialh5xc 0 411805 3523813 3505563 2026-07-10T19:50:26Z Neriassel 28746 lap visszaállítása szótárcikk szintre 3523813 wikitext text/x-wiki {{denoun|m:f,,s}} #[[bitcoin]] {{denounr|m:f,,s}} kbgcmz43wul6bltxofv4qzt6fbswee8 0 429810 3523810 3495533 2026-07-10T19:48:08Z Neriassel 28746 lap visszaállítása szótárcikk szintre 3523810 wikitext text/x-wiki {{hunfn}} #{{matematika|lang=hu}} {{-ford-}} *{{en}}: {{t|en|game theory}} *{{fr}}: {{t|fr|théorie des jeux}} *{{de}}: {{t|de|Spieltheorie}} *{{ru}}: {{t|ru|теория игр }} {{hunl}} ippayl6s62pfz82oeb99haze6vhk40v 0 431200 3523807 3495878 2026-07-10T19:44:49Z Neriassel 28746 lap visszaállítása szótárcikk szintre. nem a wikipédián vagyunk 3523807 wikitext text/x-wiki {{hunfn}} #{{humatek}} *{{en}}: {{t|en|operations research}}, {{t|en|operational research}} *{{fr}}: {{t|fr|recherche opérationnelle}} *{{ru}}: {{t|ru|исследование операций}} {{hunl}} f7xc1534cgg1la4ht16nvds77psf17z 828 720265 3523805 3324959 2026-07-10T17:04:03Z Uzume 4483 Update from [[d:Special:GoToLinkedPage/enwiki/Q24733825|master]] using [[mw:Synchronizer| #Synchronizer]] 3523805 Scribunto text/plain -- Original module located at [[:en:Module:Wd]] and [[:en:Module:Wd/i18n]]. require("strict") local p = {} local module_arg = ... local i18n local i18nPath local function loadI18n(aliasesP, frame) local title if frame then -- current module invoked by page/template, get its title from frame title = frame:getTitle() else -- current module included by other module, get its title from ... title = module_arg end if not i18n then i18nPath = title .. "/i18n" i18n = require(i18nPath).init(aliasesP) end end p.claimCommands = { property = "property", properties = "properties", qualifier = "qualifier", qualifiers = "qualifiers", reference = "reference", references = "references" } p.generalCommands = { label = "label", title = "title", description = "description", alias = "alias", aliases = "aliases", badge = "badge", badges = "badges" } p.flags = { linked = "linked", short = "short", raw = "raw", multilanguage = "multilanguage", unit = "unit", ------------- preferred = "preferred", normal = "normal", deprecated = "deprecated", best = "best", future = "future", current = "current", former = "former", edit = "edit", editAtEnd = "edit@end", mdy = "mdy", single = "single", sourced = "sourced" } p.args = { eid = "eid", page = "page", date = "date", globalSiteId = "globalSiteId" } local aliasesP = { coord = "P625", ----------------------- image = "P18", author = "P50", authorNameString = "P2093", publisher = "P123", importedFrom = "P143", wikimediaImportURL = "P4656", statedIn = "P248", pages = "P304", language = "P407", hasPart = "P527", publicationDate = "P577", startTime = "P580", endTime = "P582", chapter = "P792", retrieved = "P813", referenceURL = "P854", sectionVerseOrParagraph = "P958", archiveURL = "P1065", title = "P1476", formatterURL = "P1630", quote = "P1683", shortName = "P1813", definingFormula = "P2534", archiveDate = "P2960", inferredFrom = "P3452", typeOfReference = "P3865", column = "P3903", subjectNamedAs = "P1810", wikidataProperty = "P1687", publishedIn = "P1433", lastUpdate = "P5017" } local aliasesQ = { percentage = "Q11229", prolepticJulianCalendar = "Q1985786", citeWeb = "Q5637226", citeQ = "Q22321052" } local parameters = { property = "%p", qualifier = "%q", reference = "%r", alias = "%a", badge = "%b", separator = "%s", general = "%x" } local formats = { property = "%p[%s][%r]", qualifier = "%q[%s][%r]", reference = "%r", propertyWithQualifier = "%p[ <span style=\"font-size:85\\%\">(%q)</span>][%s][%r]", alias = "%a[%s]", badge = "%b[%s]" } local hookNames = { -- {level_1, level_2} [parameters.property] = {"getProperty"}, [parameters.reference] = {"getReferences", "getReference"}, [parameters.qualifier] = {"getAllQualifiers"}, [parameters.qualifier.."\\d"] = {"getQualifiers", "getQualifier"}, [parameters.alias] = {"getAlias"}, [parameters.badge] = {"getBadge"} } -- default value objects, should NOT be mutated but instead copied local defaultSeparators = { ["sep"] = {" "}, ["sep%s"] = {","}, ["sep%q"] = {"; "}, ["sep%q\\d"] = {", "}, ["sep%r"] = nil, -- none ["punc"] = nil -- none } local rankTable = { ["preferred"] = 1, ["normal"] = 2, ["deprecated"] = 3 } local function replaceAlias(id) if aliasesP[id] then id = aliasesP[id] end return id end local function errorText(code, ...) local text = i18n["errors"][code] if arg then text = mw.ustring.format(text, unpack(arg)) end return text end local function throwError(errorMessage, ...) error(errorText(errorMessage, unpack(arg))) end local function replaceDecimalMark(num) return mw.ustring.gsub(num, "[.]", i18n['numeric']['decimal-mark'], 1) end local function padZeros(num, numDigits) local numZeros local negative = false if num < 0 then negative = true num = num * -1 end num = tostring(num) numZeros = numDigits - num:len() for _ = 1, numZeros do num = "0"..num end if negative then num = "-"..num end return num end local function replaceSpecialChar(chr) if chr == '_' then -- replace underscores with spaces return ' ' else return chr end end local function replaceSpecialChars(str) local chr local esc = false local strOut = "" for i = 1, #str do chr = str:sub(i,i) if not esc then if chr == '\\' then esc = true else strOut = strOut .. replaceSpecialChar(chr) end else strOut = strOut .. chr esc = false end end return strOut end local function buildWikilink(target, label) if not label or target == label then return "[[" .. target .. "]]" else return "[[" .. target .. "|" .. label .. "]]" end end -- used to make frame.args mutable, to replace #frame.args (which is always 0) -- with the actual amount and to simply copy tables local function copyTable(tIn) if not tIn then return nil end local tOut = {} for i, v in pairs(tIn) do tOut[i] = v end return tOut end -- used to merge output arrays together; -- note that it currently mutates the first input array local function mergeArrays(a1, a2) for i = 1, #a2 do a1[#a1 + 1] = a2[i] end return a1 end local function split(str, del) local out = {} local i, j = str:find(del) if i and j then out[1] = str:sub(1, i - 1) out[2] = str:sub(j + 1) else out[1] = str end return out end local function parseWikidataURL(url) local id if url:match('^http[s]?://') then id = split(url, "Q") if id[2] then return "Q" .. id[2] end end return nil end local function parseDate(dateStr, precision) precision = precision or "d" local i, j, index, ptr local parts = {nil, nil, nil} if dateStr == nil then return parts[1], parts[2], parts[3] -- year, month, day end -- 'T' for snak values, '/' for outputs with '/Julian' attached i, j = dateStr:find("[T/]") if i then dateStr = dateStr:sub(1, i-1) end local from = 1 if dateStr:sub(1,1) == "-" then -- this is a negative number, look further ahead from = 2 end index = 1 ptr = 1 i, j = dateStr:find("-", from) if i then -- year parts[index] = tonumber(dateStr:sub(ptr, i-1), 10) -- explicitly give base 10 to prevent error if parts[index] == -0 then parts[index] = tonumber("0") -- for some reason, 'parts[index] = 0' may actually store '-0', so parse from string instead end if precision == "y" then -- we're done return parts[1], parts[2], parts[3] -- year, month, day end index = index + 1 ptr = i + 1 i, j = dateStr:find("-", ptr) if i then -- month parts[index] = tonumber(dateStr:sub(ptr, i-1), 10) if precision == "m" then -- we're done return parts[1], parts[2], parts[3] -- year, month, day end index = index + 1 ptr = i + 1 end end if dateStr:sub(ptr) ~= "" then -- day if we have month, month if we have year, or year parts[index] = tonumber(dateStr:sub(ptr), 10) end return parts[1], parts[2], parts[3] -- year, month, day end local function datePrecedesDate(aY, aM, aD, bY, bM, bD) if aY == nil or bY == nil then return nil end aM = aM or 1 aD = aD or 1 bM = bM or 1 bD = bD or 1 if aY < bY then return true end if aY > bY then return false end if aM < bM then return true end if aM > bM then return false end if aD < bD then return true end return false end local function getHookName(param, index) if hookNames[param] then return hookNames[param][index] elseif param:len() > 2 then return hookNames[param:sub(1, 2).."\\d"][index] else return nil end end local function alwaysTrue() return true end -- The following function parses a format string. -- -- The example below shows how a parsed string is structured in memory. -- Variables other than 'str' and 'child' are left out for clarity's sake. -- -- Example: -- "A %p B [%s[%q1]] C [%r] D" -- -- Structure: -- [ -- { -- str = "A " -- }, -- { -- str = "%p" -- }, -- { -- str = " B ", -- child = -- [ -- { -- str = "%s", -- child = -- [ -- { -- str = "%q1" -- } -- ] -- } -- ] -- }, -- { -- str = " C ", -- child = -- [ -- { -- str = "%r" -- } -- ] -- }, -- { -- str = " D" -- } -- ] -- local function parseFormat(str) local chr, esc, param, root, cur, prev, new local params = {} local function newObject(array) local obj = {} -- new object obj.str = "" array[#array + 1] = obj -- array{object} obj.parent = array return obj end local function endParam() if param > 0 then if cur.str ~= "" then cur.str = "%"..cur.str cur.param = true params[cur.str] = true cur.parent.req[cur.str] = true prev = cur cur = newObject(cur.parent) end param = 0 end end root = {} -- array root.req = {} cur = newObject(root) prev = nil esc = false param = 0 for i = 1, #str do chr = str:sub(i,i) if not esc then if chr == '\\' then endParam() esc = true elseif chr == '%' then endParam() if cur.str ~= "" then cur = newObject(cur.parent) end param = 2 elseif chr == '[' then endParam() if prev and cur.str == "" then table.remove(cur.parent) cur = prev end cur.child = {} -- new array cur.child.req = {} cur.child.parent = cur cur = newObject(cur.child) elseif chr == ']' then endParam() if cur.parent.parent then new = newObject(cur.parent.parent.parent) if cur.str == "" then table.remove(cur.parent) end cur = new end else if param > 1 then param = param - 1 elseif param == 1 then if not chr:match('%d') then endParam() end end cur.str = cur.str .. replaceSpecialChar(chr) end else cur.str = cur.str .. chr esc = false end prev = nil end endParam() -- make sure that at least one required parameter has been defined if not next(root.req) then throwError("missing-required-parameter") end -- make sure that the separator parameter "%s" is not amongst the required parameters if root.req[parameters.separator] then throwError("extra-required-parameter", parameters.separator) end return root, params end local function sortOnRank(claims) local rankPos local ranks = {{}, {}, {}, {}} -- preferred, normal, deprecated, (default) local sorted = {} for _, v in ipairs(claims) do rankPos = rankTable[v.rank] or 4 ranks[rankPos][#ranks[rankPos] + 1] = v end sorted = ranks[1] sorted = mergeArrays(sorted, ranks[2]) sorted = mergeArrays(sorted, ranks[3]) return sorted end local function isValueInTable(searchedItem, inputTable) for _, item in pairs(inputTable) do if item == searchedItem then return true end end return false end local Config = {} -- allows for recursive calls function Config:new() local cfg = {} setmetatable(cfg, self) self.__index = self cfg.separators = { -- single value objects wrapped in arrays so that we can pass by reference ["sep"] = {copyTable(defaultSeparators["sep"])}, ["sep%s"] = {copyTable(defaultSeparators["sep%s"])}, ["sep%q"] = {copyTable(defaultSeparators["sep%q"])}, ["sep%r"] = {copyTable(defaultSeparators["sep%r"])}, ["punc"] = {copyTable(defaultSeparators["punc"])} } cfg.entity = nil cfg.entityID = nil cfg.propertyID = nil cfg.propertyValue = nil cfg.qualifierIDs = {} cfg.qualifierIDsAndValues = {} cfg.bestRank = true cfg.ranks = {true, true, false} -- preferred = true, normal = true, deprecated = false cfg.foundRank = #cfg.ranks cfg.flagBest = false cfg.flagRank = false cfg.periods = {true, true, true} -- future = true, current = true, former = true cfg.flagPeriod = false cfg.atDate = {parseDate(os.date('!%Y-%m-%d'))} -- today as {year, month, day} cfg.mdyDate = false cfg.singleClaim = false cfg.sourcedOnly = false cfg.editable = false cfg.editAtEnd = false cfg.inSitelinks = false cfg.langCode = mw.language.getContentLanguage().code cfg.langName = mw.language.fetchLanguageName(cfg.langCode, cfg.langCode) cfg.langObj = mw.language.new(cfg.langCode) cfg.siteID = mw.wikibase.getGlobalSiteId() cfg.states = {} cfg.states.qualifiersCount = 0 cfg.curState = nil cfg.prefetchedRefs = nil return cfg end local State = {} function State:new(cfg, type) local stt = {} setmetatable(stt, self) self.__index = self stt.conf = cfg stt.type = type stt.results = {} stt.parsedFormat = {} stt.separator = {} stt.movSeparator = {} stt.puncMark = {} stt.linked = false stt.rawValue = false stt.shortName = false stt.anyLanguage = false stt.unitOnly = false stt.singleValue = false return stt end -- if id == nil then item connected to current page is used function Config:getLabel(id, raw, link, short) local label = nil local prefix, title= "", nil if not id then id = mw.wikibase.getEntityIdForCurrentPage() if not id then return "" end end id = id:upper() -- just to be sure if raw then -- check if given id actually exists if mw.wikibase.isValidEntityId(id) and mw.wikibase.entityExists(id) then label = id end prefix, title = "d:Special:EntityPage/", label -- may be nil else -- try short name first if requested if short then label = p._property{aliasesP.shortName, [p.args.eid] = id} -- get short name if label == "" then label = nil end end -- get label if not label then label = mw.wikibase.getLabel(id) end end if not label then label = "" elseif link then -- build a link if requested if not title then if id:sub(1,1) == "Q" then title = mw.wikibase.getSitelink(id) elseif id:sub(1,1) == "P" then -- properties have no sitelink, link to Wikidata instead prefix, title = "d:Special:EntityPage/", id end end label = mw.text.nowiki(label) -- escape raw label text so it cannot be wikitext markup if title then label = buildWikilink(prefix .. title, label) end end return label end function Config:getEditIcon() local value = "" local prefix = "" local front = "&nbsp;" local back = "" if self.entityID:sub(1,1) == "P" then prefix = "Property:" end if self.editAtEnd then front = '<span style="float:' if self.langObj:isRTL() then front = front .. 'left' else front = front .. 'right' end front = front .. '">' back = '</span>' end value = "[[File:OOjs UI icon edit-ltr-progressive.svg|frameless|text-top|10px|alt=" .. i18n['info']['edit-on-wikidata'] .. "|link=https://www.wikidata.org/wiki/" .. prefix .. self.entityID .. "?uselang=" .. self.langCode if self.propertyID then value = value .. "#" .. self.propertyID elseif self.inSitelinks then value = value .. "#sitelinks-wikipedia" end value = value .. "|" .. i18n['info']['edit-on-wikidata'] .. "]]" return front .. value .. back end -- used to create the final output string when it's all done, so that for references the -- function extensionTag("ref", ...) is only called when they really ended up in the final output function Config:concatValues(valuesArray) local outString = "" local j, skip for i = 1, #valuesArray do -- check if this is a reference if valuesArray[i].refHash then j = i - 1 skip = false -- skip this reference if it is part of a continuous row of references that already contains the exact same reference while valuesArray[j] and valuesArray[j].refHash do if valuesArray[i].refHash == valuesArray[j].refHash then skip = true break end j = j - 1 end if not skip then -- add <ref> tag with the reference's hash as its name (to deduplicate references) outString = outString .. mw.getCurrentFrame():extensionTag("ref", valuesArray[i][1], {name = valuesArray[i].refHash}) end else outString = outString .. valuesArray[i][1] end end return outString end function Config:convertUnit(unit, raw, link, short, unitOnly) local space = " " local label = "" local itemID if unit == "" or unit == "1" then return nil end if unitOnly then space = "" end itemID = parseWikidataURL(unit) if itemID then if itemID == aliasesQ.percentage then return "%" else label = self:getLabel(itemID, raw, link, short) if label ~= "" then return space .. label end end end return "" end function State:getValue(snak) return self.conf:getValue(snak, self.rawValue, self.linked, self.shortName, self.anyLanguage, self.unitOnly, false, self.type:sub(1,2)) end function Config:getValue(snak, raw, link, short, anyLang, unitOnly, noSpecial, type) if snak.snaktype == 'value' then local datatype = snak.datavalue.type local subtype = snak.datatype local datavalue = snak.datavalue.value if datatype == 'string' then if subtype == 'url' and link then -- create link explicitly if raw then -- will render as a linked number like [1] return "[" .. datavalue .. "]" else return "[" .. datavalue .. " " .. datavalue .. "]" end elseif subtype == 'commonsMedia' then if link then return buildWikilink("c:File:" .. datavalue, datavalue) elseif not raw then return "[[File:" .. datavalue .. "]]" else return datavalue end elseif subtype == 'geo-shape' and link then return buildWikilink("c:" .. datavalue, datavalue) elseif subtype == 'math' and not raw then local attribute = nil if (type == parameters.property or (type == parameters.qualifier and self.propertyID == aliasesP.hasPart)) and snak.property == aliasesP.definingFormula then attribute = {qid = self.entityID} end return mw.getCurrentFrame():extensionTag("math", datavalue, attribute) elseif subtype == 'external-id' and link then local url = p._property{aliasesP.formatterURL, [p.args.eid] = snak.property} -- get formatter URL if url ~= "" then url = mw.ustring.gsub(url, "$1", datavalue) return "[" .. url .. " " .. datavalue .. "]" else return datavalue end else return datavalue end elseif datatype == 'monolingualtext' then if anyLang or datavalue['language'] == self.langCode then return datavalue['text'] else return nil end elseif datatype == 'quantity' then local value = "" local unit if not unitOnly then -- get value and strip + signs from front value = mw.ustring.gsub(datavalue['amount'], "^%+(.+)$", "%1") if raw then return value end -- replace decimal mark based on locale value = replaceDecimalMark(value) -- add delimiters for readability value = i18n.addDelimiters(value) end unit = self:convertUnit(datavalue['unit'], raw, link, short, unitOnly) if unit then value = value .. unit end return value elseif datatype == 'time' then local y, m, d, p, yDiv, yRound, yFull, value, calendarID, dateStr local yFactor = 1 local sign = 1 local prefix = "" local suffix = "" local mayAddCalendar = false local calendar = "" local precision = datavalue['precision'] if precision == 11 then p = "d" elseif precision == 10 then p = "m" else p = "y" yFactor = 10^(9-precision) end y, m, d = parseDate(datavalue['time'], p) if y < 0 then sign = -1 y = y * sign end -- if precision is tens/hundreds/thousands/millions/billions of years if precision <= 8 then yDiv = y / yFactor -- if precision is tens/hundreds/thousands of years if precision >= 6 then mayAddCalendar = true if precision <= 7 then -- round centuries/millenniums up (e.g. 20th century or 3rd millennium) yRound = math.ceil(yDiv) if not raw then if precision == 6 then suffix = i18n['datetime']['suffixes']['millennium'] else suffix = i18n['datetime']['suffixes']['century'] end suffix = i18n.getOrdinalSuffix(yRound) .. suffix else -- if not verbose, take the first year of the century/millennium -- (e.g. 1901 for 20th century or 2001 for 3rd millennium) yRound = (yRound - 1) * yFactor + 1 end else -- precision == 8 -- round decades down (e.g. 2010s) yRound = math.floor(yDiv) * yFactor if not raw then prefix = i18n['datetime']['prefixes']['decade-period'] suffix = i18n['datetime']['suffixes']['decade-period'] end end if raw and sign < 0 then -- if BCE then compensate for "counting backwards" -- (e.g. -2019 for 2010s BCE, -2000 for 20th century BCE or -3000 for 3rd millennium BCE) yRound = yRound + yFactor - 1 end else local yReFactor, yReDiv, yReRound -- round to nearest for tens of thousands of years or more yRound = math.floor(yDiv + 0.5) if yRound == 0 then if precision <= 2 and y ~= 0 then yReFactor = 1e6 yReDiv = y / yReFactor yReRound = math.floor(yReDiv + 0.5) if yReDiv == yReRound then -- change precision to millions of years only if we have a whole number of them precision = 3 yFactor = yReFactor yRound = yReRound end end if yRound == 0 then -- otherwise, take the unrounded (original) number of years precision = 5 yFactor = 1 yRound = y mayAddCalendar = true end end if precision >= 1 and y ~= 0 then yFull = yRound * yFactor yReFactor = 1e9 yReDiv = yFull / yReFactor yReRound = math.floor(yReDiv + 0.5) if yReDiv == yReRound then -- change precision to billions of years if we're in that range precision = 0 yFactor = yReFactor yRound = yReRound else yReFactor = 1e6 yReDiv = yFull / yReFactor yReRound = math.floor(yReDiv + 0.5) if yReDiv == yReRound then -- change precision to millions of years if we're in that range precision = 3 yFactor = yReFactor yRound = yReRound end end end if not raw then if precision == 3 then suffix = i18n['datetime']['suffixes']['million-years'] elseif precision == 0 then suffix = i18n['datetime']['suffixes']['billion-years'] else yRound = yRound * yFactor if yRound == 1 then suffix = i18n['datetime']['suffixes']['year'] else suffix = i18n['datetime']['suffixes']['years'] end end else yRound = yRound * yFactor end end else yRound = y mayAddCalendar = true end if mayAddCalendar then calendarID = parseWikidataURL(datavalue['calendarmodel']) if calendarID and calendarID == aliasesQ.prolepticJulianCalendar then if not raw then if link then calendar = " ("..buildWikilink(i18n['datetime']['julian-calendar'], i18n['datetime']['julian'])..")" else calendar = " ("..i18n['datetime']['julian']..")" end else calendar = "/"..i18n['datetime']['julian'] end end end if not raw then local ce = nil if sign < 0 then ce = i18n['datetime']['BCE'] elseif precision <= 5 then ce = i18n['datetime']['CE'] end if ce then if link then ce = buildWikilink(i18n['datetime']['common-era'], ce) end suffix = suffix .. " " .. ce end value = tostring(yRound) if m then dateStr = self.langObj:formatDate("F", "1-"..m.."-1") if d then if self.mdyDate then dateStr = dateStr .. " " .. d .. "," else dateStr = d .. " " .. dateStr end end value = dateStr .. " " .. value end value = prefix .. value .. suffix .. calendar else value = padZeros(yRound * sign, 4) if m then value = value .. "-" .. padZeros(m, 2) if d then value = value .. "-" .. padZeros(d, 2) end end value = value .. calendar end return value elseif datatype == 'globecoordinate' then -- logic from https://github.com/DataValues/Geo (v4.0.1) local precision, unitsPerDegree, numDigits, strFormat, value, globe local latitude, latConv, latValue, latLink local longitude, lonConv, lonValue, lonLink local latDirection, latDirectionN, latDirectionS, latDirectionEN local lonDirection, lonDirectionE, lonDirectionW, lonDirectionEN local degSymbol, minSymbol, secSymbol, separator local latDegrees = nil local latMinutes = nil local latSeconds = nil local lonDegrees = nil local lonMinutes = nil local lonSeconds = nil local latDegSym = "" local latMinSym = "" local latSecSym = "" local lonDegSym = "" local lonMinSym = "" local lonSecSym = "" local latDirectionEN_N = "N" local latDirectionEN_S = "S" local lonDirectionEN_E = "E" local lonDirectionEN_W = "W" if not raw then latDirectionN = i18n['coord']['latitude-north'] latDirectionS = i18n['coord']['latitude-south'] lonDirectionE = i18n['coord']['longitude-east'] lonDirectionW = i18n['coord']['longitude-west'] degSymbol = i18n['coord']['degrees'] minSymbol = i18n['coord']['minutes'] secSymbol = i18n['coord']['seconds'] separator = i18n['coord']['separator'] else latDirectionN = latDirectionEN_N latDirectionS = latDirectionEN_S lonDirectionE = lonDirectionEN_E lonDirectionW = lonDirectionEN_W degSymbol = "/" minSymbol = "/" secSymbol = "/" separator = "/" end latitude = datavalue['latitude'] longitude = datavalue['longitude'] if latitude < 0 then latDirection = latDirectionS latDirectionEN = latDirectionEN_S latitude = math.abs(latitude) else latDirection = latDirectionN latDirectionEN = latDirectionEN_N end if longitude < 0 then lonDirection = lonDirectionW lonDirectionEN = lonDirectionEN_W longitude = math.abs(longitude) else lonDirection = lonDirectionE lonDirectionEN = lonDirectionEN_E end precision = datavalue['precision'] if not precision or precision <= 0 then precision = 1 / 3600 -- precision not set (correctly), set to arcsecond end -- remove insignificant detail latitude = math.floor(latitude / precision + 0.5) * precision longitude = math.floor(longitude / precision + 0.5) * precision if precision >= 1 - (1 / 60) and precision < 1 then precision = 1 elseif precision >= (1 / 60) - (1 / 3600) and precision < (1 / 60) then precision = 1 / 60 end if precision >= 1 then unitsPerDegree = 1 elseif precision >= (1 / 60) then unitsPerDegree = 60 else unitsPerDegree = 3600 end numDigits = math.ceil(-math.log10(unitsPerDegree * precision)) if numDigits <= 0 then numDigits = tonumber("0") -- for some reason, 'numDigits = 0' may actually store '-0', so parse from string instead end strFormat = "%." .. numDigits .. "f" if precision >= 1 then latDegrees = strFormat:format(latitude) lonDegrees = strFormat:format(longitude) if not raw then latDegSym = replaceDecimalMark(latDegrees) .. degSymbol lonDegSym = replaceDecimalMark(lonDegrees) .. degSymbol else latDegSym = latDegrees .. degSymbol lonDegSym = lonDegrees .. degSymbol end else latConv = math.floor(latitude * unitsPerDegree * 10^numDigits + 0.5) / 10^numDigits lonConv = math.floor(longitude * unitsPerDegree * 10^numDigits + 0.5) / 10^numDigits if precision >= (1 / 60) then latMinutes = latConv lonMinutes = lonConv else latSeconds = latConv lonSeconds = lonConv latMinutes = math.floor(latSeconds / 60) lonMinutes = math.floor(lonSeconds / 60) latSeconds = strFormat:format(latSeconds - (latMinutes * 60)) lonSeconds = strFormat:format(lonSeconds - (lonMinutes * 60)) if not raw then latSecSym = replaceDecimalMark(latSeconds) .. secSymbol lonSecSym = replaceDecimalMark(lonSeconds) .. secSymbol else latSecSym = latSeconds .. secSymbol lonSecSym = lonSeconds .. secSymbol end end latDegrees = math.floor(latMinutes / 60) lonDegrees = math.floor(lonMinutes / 60) latDegSym = latDegrees .. degSymbol lonDegSym = lonDegrees .. degSymbol latMinutes = latMinutes - (latDegrees * 60) lonMinutes = lonMinutes - (lonDegrees * 60) if precision >= (1 / 60) then latMinutes = strFormat:format(latMinutes) lonMinutes = strFormat:format(lonMinutes) if not raw then latMinSym = replaceDecimalMark(latMinutes) .. minSymbol lonMinSym = replaceDecimalMark(lonMinutes) .. minSymbol else latMinSym = latMinutes .. minSymbol lonMinSym = lonMinutes .. minSymbol end else latMinSym = latMinutes .. minSymbol lonMinSym = lonMinutes .. minSymbol end end latValue = latDegSym .. latMinSym .. latSecSym .. latDirection lonValue = lonDegSym .. lonMinSym .. lonSecSym .. lonDirection value = latValue .. separator .. lonValue if link then globe = parseWikidataURL(datavalue['globe']) if globe then globe = mw.wikibase.getLabelByLang(globe, "en"):lower() else globe = "earth" end latLink = table.concat({latDegrees, latMinutes, latSeconds}, "_") lonLink = table.concat({lonDegrees, lonMinutes, lonSeconds}, "_") value = "[https://geohack.toolforge.org/geohack.php?language="..self.langCode.."&params="..latLink.."_"..latDirectionEN.."_"..lonLink.."_"..lonDirectionEN.."_globe:"..globe.." "..value.."]" end return value elseif datatype == 'wikibase-entityid' then local label local itemID = datavalue['numeric-id'] if subtype == 'wikibase-item' then itemID = "Q" .. itemID elseif subtype == 'wikibase-property' then itemID = "P" .. itemID else return '<strong class="error">' .. errorText('unknown-data-type', subtype) .. '</strong>' end label = self:getLabel(itemID, raw, link, short) if label == "" then label = nil end return label else return '<strong class="error">' .. errorText('unknown-data-type', datatype) .. '</strong>' end elseif snak.snaktype == 'somevalue' and not noSpecial then if raw then return " " -- single space represents 'somevalue' else return i18n['values']['unknown'] end elseif snak.snaktype == 'novalue' and not noSpecial then if raw then return "" -- empty string represents 'novalue' else return i18n['values']['none'] end else return nil end end function Config:getSingleRawQualifier(claim, qualifierID) local qualifiers if claim.qualifiers then qualifiers = claim.qualifiers[qualifierID] end if qualifiers and qualifiers[1] then return self:getValue(qualifiers[1], true) -- raw = true else return nil end end function Config:snakEqualsValue(snak, value) local snakValue = self:getValue(snak, true) -- raw = true if snakValue and snak.snaktype == 'value' and snak.datavalue.type == 'wikibase-entityid' then value = value:upper() end return snakValue == value end function Config:setRank(rank) local rankPos if rank == p.flags.best then self.bestRank = true self.flagBest = true -- mark that 'best' flag was given return end if rank:sub(1,9) == p.flags.preferred then rankPos = 1 elseif rank:sub(1,6) == p.flags.normal then rankPos = 2 elseif rank:sub(1,10) == p.flags.deprecated then rankPos = 3 else return end -- one of the rank flags was given, check if another one was given before if not self.flagRank then self.ranks = {false, false, false} -- no other rank flag given before, so unset ranks self.bestRank = self.flagBest -- unsets bestRank only if 'best' flag was not given before self.flagRank = true -- mark that a rank flag was given end if rank:sub(-1) == "+" then for i = rankPos, 1, -1 do self.ranks[i] = true end elseif rank:sub(-1) == "-" then for i = rankPos, #self.ranks do self.ranks[i] = true end else self.ranks[rankPos] = true end end function Config:setPeriod(period) local periodPos if period == p.flags.future then periodPos = 1 elseif period == p.flags.current then periodPos = 2 elseif period == p.flags.former then periodPos = 3 else return end -- one of the period flags was given, check if another one was given before if not self.flagPeriod then self.periods = {false, false, false} -- no other period flag given before, so unset periods self.flagPeriod = true -- mark that a period flag was given end self.periods[periodPos] = true end function Config:qualifierMatches(claim, id, value) local qualifiers if claim.qualifiers then qualifiers = claim.qualifiers[id] end if qualifiers then for _, v in pairs(qualifiers) do if self:snakEqualsValue(v, value) then return true end end elseif value == "" then -- if the qualifier is not present then treat it the same as the special value 'novalue' return true end return false end function Config:rankMatches(rankPos) if self.bestRank then return (self.ranks[rankPos] and self.foundRank >= rankPos) else return self.ranks[rankPos] end end function Config:timeMatches(claim) local startTime = nil local startTimeY = nil local startTimeM = nil local startTimeD = nil local endTime = nil local endTimeY = nil local endTimeM = nil local endTimeD = nil if self.periods[1] and self.periods[2] and self.periods[3] then -- any time return true end startTime = self:getSingleRawQualifier(claim, aliasesP.startTime) if startTime and startTime ~= "" and startTime ~= " " then startTimeY, startTimeM, startTimeD = parseDate(startTime) end endTime = self:getSingleRawQualifier(claim, aliasesP.endTime) if endTime and endTime ~= "" and endTime ~= " " then endTimeY, endTimeM, endTimeD = parseDate(endTime) end if startTimeY ~= nil and endTimeY ~= nil and datePrecedesDate(endTimeY, endTimeM, endTimeD, startTimeY, startTimeM, startTimeD) then -- invalidate end time if it precedes start time endTimeY = nil endTimeM = nil endTimeD = nil end if self.periods[1] then -- future if startTimeY and datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], startTimeY, startTimeM, startTimeD) then return true end end if self.periods[2] then -- current if (startTimeY == nil or not datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], startTimeY, startTimeM, startTimeD)) and (endTimeY == nil or datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], endTimeY, endTimeM, endTimeD)) then return true end end if self.periods[3] then -- former if endTimeY and not datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], endTimeY, endTimeM, endTimeD) then return true end end return false end function Config:processFlag(flag) if not flag then return false end if flag == p.flags.linked then self.curState.linked = true return true elseif flag == p.flags.raw then self.curState.rawValue = true if self.curState == self.states[parameters.reference] then -- raw reference values end with periods and require a separator (other than none) self.separators["sep%r"][1] = {" "} end return true elseif flag == p.flags.short then self.curState.shortName = true return true elseif flag == p.flags.multilanguage then self.curState.anyLanguage = true return true elseif flag == p.flags.unit then self.curState.unitOnly = true return true elseif flag == p.flags.mdy then self.mdyDate = true return true elseif flag == p.flags.single then self.singleClaim = true return true elseif flag == p.flags.sourced then self.sourcedOnly = true return true elseif flag == p.flags.edit then self.editable = true return true elseif flag == p.flags.editAtEnd then self.editable = true self.editAtEnd = true return true elseif flag == p.flags.best or flag:match('^'..p.flags.preferred..'[+-]?$') or flag:match('^'..p.flags.normal..'[+-]?$') or flag:match('^'..p.flags.deprecated..'[+-]?$') then self:setRank(flag) return true elseif flag == p.flags.future or flag == p.flags.current or flag == p.flags.former then self:setPeriod(flag) return true elseif flag == "" then -- ignore empty flags and carry on return true else return false end end function Config:processFlagOrCommand(flag) local param = "" if not flag then return false end if flag == p.claimCommands.property or flag == p.claimCommands.properties then param = parameters.property elseif flag == p.claimCommands.qualifier or flag == p.claimCommands.qualifiers then self.states.qualifiersCount = self.states.qualifiersCount + 1 param = parameters.qualifier .. self.states.qualifiersCount self.separators["sep"..param] = {copyTable(defaultSeparators["sep%q\\d"])} elseif flag == p.claimCommands.reference or flag == p.claimCommands.references then param = parameters.reference else return self:processFlag(flag) end if self.states[param] then return false end -- create a new state for each command self.states[param] = State:new(self, param) -- use "%x" as the general parameter name self.states[param].parsedFormat = parseFormat(parameters.general) -- will be overwritten for param=="%p" -- set the separator self.states[param].separator = self.separators["sep"..param] -- will be nil for param=="%p", which will be set separately if flag == p.claimCommands.property or flag == p.claimCommands.qualifier or flag == p.claimCommands.reference then self.states[param].singleValue = true end self.curState = self.states[param] return true end function Config:processSeparators(args) local sep for i, v in pairs(self.separators) do if args[i] then sep = replaceSpecialChars(args[i]) if sep ~= "" then self.separators[i][1] = {sep} else self.separators[i][1] = nil end end end end function Config:setFormatAndSeparators(state, parsedFormat) state.parsedFormat = parsedFormat state.separator = self.separators["sep"] state.movSeparator = self.separators["sep"..parameters.separator] state.puncMark = self.separators["punc"] end -- determines if a claim has references by prefetching them from the claim using getReferences, -- which applies some filtering that determines if a reference is actually returned, -- and caches the references for later use function State:isSourced(claim) self.conf.prefetchedRefs = self:getReferences(claim) return (#self.conf.prefetchedRefs > 0) end function State:resetCaches() -- any prefetched references of the previous claim must not be used self.conf.prefetchedRefs = nil end function State:claimMatches(claim) local matches, rankPos -- first of all, reset any cached values used for the previous claim self:resetCaches() -- if a property value was given, check if it matches the claim's property value if self.conf.propertyValue then matches = self.conf:snakEqualsValue(claim.mainsnak, self.conf.propertyValue) else matches = true end -- if any qualifier values were given, check if each matches one of the claim's qualifier values for i, v in pairs(self.conf.qualifierIDsAndValues) do matches = (matches and self.conf:qualifierMatches(claim, i, v)) end -- check if the claim's rank and time period match rankPos = rankTable[claim.rank] or 4 matches = (matches and self.conf:rankMatches(rankPos) and self.conf:timeMatches(claim)) -- if only claims with references must be returned, check if this one has any if self.conf.sourcedOnly then matches = (matches and self:isSourced(claim)) -- prefetches and caches references end return matches, rankPos end function State:out() local result -- collection of arrays with value objects local valuesArray -- array with value objects local sep = nil -- value object local out = {} -- array with value objects local function walk(formatTable, result) local valuesArray = {} -- array with value objects for i, v in pairs(formatTable.req) do if not result[i] or not result[i][1] then -- we've got no result for a parameter that is required on this level, -- so skip this level (and its children) by returning an empty result return {} end end for _, v in ipairs(formatTable) do if v.param then valuesArray = mergeArrays(valuesArray, result[v.str]) elseif v.str ~= "" then valuesArray[#valuesArray + 1] = {v.str} end if v.child then valuesArray = mergeArrays(valuesArray, walk(v.child, result)) end end return valuesArray end -- iterate through the results from back to front, so that we know when to add separators for i = #self.results, 1, -1 do result = self.results[i] -- if there is already some output, then add the separators if #out > 0 then sep = self.separator[1] -- fixed separator result[parameters.separator] = {self.movSeparator[1]} -- movable separator else sep = nil result[parameters.separator] = {self.puncMark[1]} -- optional punctuation mark end valuesArray = walk(self.parsedFormat, result) if #valuesArray > 0 then if sep then valuesArray[#valuesArray + 1] = sep end out = mergeArrays(valuesArray, out) end end -- reset state before next iteration self.results = {} return out end -- level 1 hook function State:getProperty(claim) local value = {self:getValue(claim.mainsnak)} -- create one value object if #value > 0 then return {value} -- wrap the value object in an array and return it else return {} -- return empty array if there was no value end end -- level 1 hook function State:getQualifiers(claim, param) local qualifiers if claim.qualifiers then qualifiers = claim.qualifiers[self.conf.qualifierIDs[param]] end if qualifiers then -- iterate through claim's qualifier statements to collect their values; -- return array with multiple value objects return self.conf.states[param]:iterate(qualifiers, {[parameters.general] = hookNames[parameters.qualifier.."\\d"][2], count = 1}) -- pass qualifier state with level 2 hook else return {} -- return empty array end end -- level 2 hook function State:getQualifier(snak) local value = {self:getValue(snak)} -- create one value object if #value > 0 then return {value} -- wrap the value object in an array and return it else return {} -- return empty array if there was no value end end -- level 1 hook function State:getAllQualifiers(claim, param, result, hooks) local out = {} -- array with value objects local sep = self.conf.separators["sep"..parameters.qualifier][1] -- value object -- iterate through the output of the separate "qualifier(s)" commands for i = 1, self.conf.states.qualifiersCount do -- if a hook has not been called yet, call it now if not result[parameters.qualifier..i] then self:callHook(parameters.qualifier..i, hooks, claim, result) end -- if there is output for this particular "qualifier(s)" command, then add it if result[parameters.qualifier..i] and result[parameters.qualifier..i][1] then -- if there is already some output, then add the separator if #out > 0 and sep then out[#out + 1] = sep end out = mergeArrays(out, result[parameters.qualifier..i]) end end return out end -- level 1 hook function State:getReferences(claim) if self.conf.prefetchedRefs then -- return references that have been prefetched by isSourced return self.conf.prefetchedRefs end if claim.references then -- iterate through claim's reference statements to collect their values; -- return array with multiple value objects return self.conf.states[parameters.reference]:iterate(claim.references, {[parameters.general] = hookNames[parameters.reference][2], count = 1}) -- pass reference state with level 2 hook else return {} -- return empty array end end -- level 2 hook function State:getReference(statement) local citeParamMapping = i18n['cite']['param-mapping'] local citeConfig = i18n['cite']['config'] local citeTypes = i18n['cite']['output-types'] -- will hold rendered properties of the reference which are not directly from statement.snaks, -- Namely, is URL generated from an external ID. local additionalProcessedProperties = {} -- for each citation type, there will be an associative array that associates lists of rendered properties -- to citation-template parameters local candidateParams = {} -- like above, but only associates one rendered property to each parameter; if the above variable -- contains more strings for a parameter, the strings will be assigned to numbered params (e.g. "author1") local citeParams = {} local citeErrors = {} local referenceEmpty = true -- will be set to false if at least one parameter is left unremoved local version = 12 -- increment this each time the below logic is changed to avoid conflict errors if not statement.snaks then return {} end -- don't use bot-added references referencing Wikimedia projects or containing "inferred from" (such references are not usable on Wikipedia) if statement.snaks[aliasesP.importedFrom] or statement.snaks[aliasesP.wikimediaImportURL] or statement.snaks[aliasesP.inferredFrom] then return {} end -- don't include "type of reference" if statement.snaks[aliasesP.typeOfReference] then statement.snaks[aliasesP.typeOfReference] = nil end -- don't include "image" to prevent littering if statement.snaks[aliasesP.image] then statement.snaks[aliasesP.image] = nil end -- don't include "language" if it is equal to the local one if self:getReferenceDetail(statement.snaks, aliasesP.language) == self.conf.langName then statement.snaks[aliasesP.language] = nil end if statement.snaks[aliasesP.statedIn] and not statement.snaks[aliasesP.referenceURL] then -- "stated in" was given but "reference URL" was not. -- get "Wikidata property" properties from the item in "stated in" -- if any of the returned properties of the external-id datatype is in statement.snaks, generate a link from it and use the link in the reference -- find the "Wikidata property" properties in the item from "stated in" local wikidataPropertiesOfSource = mw.text.split(p._properties{p.flags.raw, aliasesP.wikidataProperty, [p.args.eid] = self.conf:getValue(statement.snaks[aliasesP.statedIn][1], true, false)}, ", ", true) for i, wikidataPropertyOfSource in pairs(wikidataPropertiesOfSource) do if statement.snaks[wikidataPropertyOfSource] and statement.snaks[wikidataPropertyOfSource][1].datatype == "external-id" then local tempLink = self:getReferenceDetail(statement.snaks, wikidataPropertyOfSource, false, true) -- not raw, linked if mw.ustring.match(tempLink, "^%[%Z- %Z+%]$") then -- getValue returned a URL in square brackets. -- the link is in wiki markup, so strip the square brackets and the display text -- gsub also returns another, discarted value, therefore the result is assigned to tempLink first tempLink = mw.ustring.gsub(tempLink, "^%[(%Z-) %Z+%]$", "%1") additionalProcessedProperties[aliasesP.referenceURL] = {tempLink} statement.snaks[wikidataPropertyOfSource] = nil break end end end end -- initialize candidateParams and citeParams for _, citeType in ipairs(citeTypes) do candidateParams[citeType] = {} citeParams[citeType] = {} end -- fill candidateParams for _, citeType in ipairs(citeTypes) do -- This will contain value--priority pairs for each param name. local candidateValuesAndPriorities = {} -- fill candidateValuesAndPriorities for refProperty in pairs(statement.snaks) do if citeErrors[citeType] then break end repeat -- just a simple wrapper to emulate "continue" -- set mappingKey and prefix local mappingKey local prefix = "" if statement.snaks[refProperty][1].datatype == 'external-id' then mappingKey = "external-id" prefix = self.conf:getLabel(refProperty) if prefix ~= "" then prefix = prefix .. " " end else mappingKey = refProperty end local paramName = citeParamMapping[citeType][mappingKey] -- skip properties with empty parameter name if paramName == "" then break -- skip this property for this value of citeType end -- handle unknown properties in the reference if not paramName then referenceEmpty = false local error_message = errorText("unknown-property-in-ref", refProperty) assert(error_message) -- Should not be nil citeErrors[citeType] = error_message break end -- set processedProperty local processedProperty local raw = false -- if the value is wanted raw if isValueInTable(paramName, citeConfig[citeType]["raw-value-params"] or {}) then raw = true end if isValueInTable(paramName, citeConfig[citeType]["numbered-params"] or {}) then -- Multiple values may be given. processedProperty = self:getReferenceDetails(statement.snaks, refProperty, raw, self.linked, true) -- anyLang = true else -- If multiple values are given, all but the first suitable one are discarted. processedProperty = {self:getReferenceDetail(statement.snaks, refProperty, raw, self.linked and (statement.snaks[refProperty][1].datatype ~= 'url'), true)} -- link = true/false, anyLang = true end if #processedProperty == 0 then break end referenceEmpty = false -- add an empty entry to candidateValuesAndPriorities, if there isn't one already if not candidateValuesAndPriorities[paramName] then candidateValuesAndPriorities[paramName] = {} end -- find the priority of refProperty local thisPropertyPriority = -1 local thisParamPrioritization = citeConfig[citeType]["prioritization"][paramName] if thisParamPrioritization then for i_priority, i_property in ipairs(thisParamPrioritization) do if i_property == refProperty then thisPropertyPriority = i_priority end end end for _, propertyValue in pairs(processedProperty) do table.insert( candidateValuesAndPriorities[paramName], {prefix .. propertyValue, thisPropertyPriority} ) end until true end -- fill candidateParams[citeType] if not citeErrors[citeType] then local compareValuePriorities = function(pair1, pair2) if pair1[2] == -1 and pair2[2] ~= -1 then return false end if pair1[2] ~= -1 and pair2[2] == -1 then return true end return pair1[2] < pair2[2] end -- fill candidateParams[citeType][paramName] for each used param for paramName, _ in pairs(candidateValuesAndPriorities) do table.sort(candidateValuesAndPriorities[paramName], compareValuePriorities) candidateParams[citeType][paramName] = {} for _, valuePriorityPair in ipairs(candidateValuesAndPriorities[paramName]) do table.insert(candidateParams[citeType][paramName], valuePriorityPair[1]) end end end end -- handle additional properties for refProperty in pairs(additionalProcessedProperties) do for _, citeType in ipairs(citeTypes) do repeat -- skip if there already have been errors if citeErrors[citeType] then break end local paramName = citeParamMapping[citeType][refProperty] -- handle unknown properties in the reference if not paramName then -- Skip this additional property, but do not cause an error. break end if paramName == "" then break end referenceEmpty = false if not candidateParams[citeType][paramName] then candidateParams[citeType][paramName] = {} end for _, propertyValue in pairs(additionalProcessedProperties[refProperty]) do table.insert(candidateParams[citeType][paramName], propertyValue) end until true end end -- fill citeParams for _, citeType in ipairs(citeTypes) do for paramName, paramValues in pairs(candidateParams[citeType]) do if #paramValues == 1 or not isValueInTable(paramName, citeConfig[citeType]["numbered-params"] or {}) then citeParams[citeType][paramName] = paramValues[1] else -- There is more than one value for this parameter - the values will -- go into separate numbered parameters (e.g. "author1", "author2") for paramNum, paramValue in pairs(paramValues) do citeParams[citeType][paramName .. paramNum] = paramValue end end end end -- handle missing mandatory parameters for the templates for _, citeType in ipairs(citeTypes) do for _, requiredCiteParam in pairs(citeConfig[citeType]["mandatory-params"] or {}) do if not citeParams[citeType][requiredCiteParam] then -- The required param is not present. if citeErrors[citeType] then -- Do not override the previous error, if it exists. break end local error_message = errorText("missing-mandatory-param", requiredCiteParam) assert(error_message) -- Should not be nil citeErrors[citeType] = error_message end end end local citeTypeToUse = nil -- choose the output template for _, citeType in ipairs(citeTypes) do if not citeErrors[citeType] then citeTypeToUse = citeType break end end -- set refContent local refContent = "" if citeTypeToUse then local templateToUse = citeConfig[citeTypeToUse]["template"] local paramsToUse = citeParams[citeTypeToUse] if not templateToUse or templateToUse == "" then throwError("no-such-reference-template", tostring(templateToUse), i18nPath, citeTypeToUse) end -- if this module is being substituted then build a regular template call, otherwise expand the template if mw.isSubsting() then for i, v in pairs(paramsToUse) do refContent = refContent .. "|" .. i .. "=" .. v end refContent = "{{" .. templateToUse .. refContent .. "}}" else xpcall( function () refContent = mw.getCurrentFrame():expandTemplate{title=templateToUse, args=paramsToUse} end, function () throwError("no-such-reference-template", templateToUse, i18nPath, citeTypeToUse) end ) end -- If the citation couldn't be displayed using any template, but is not empty (barring ignored propeties), throw an error. elseif not referenceEmpty then refContent = errorText("malformed-reference-header") for _, citeType in ipairs(citeTypes) do refContent = refContent .. errorText("template-failure-reason", citeConfig[citeType]["template"], citeErrors[citeType]) end refContent = refContent .. errorText("malformed-reference-footer") end -- wrap refContent local ref = {} if refContent ~= "" then ref = {refContent} if not self.rawValue then -- this should become a <ref> tag, so save the reference's hash for later ref.refHash = "wikidata-" .. statement.hash .. "-v" .. (tonumber(i18n['version']) + version) end return {ref} else return {} end end -- gets a detail of one particular type for a reference function State:getReferenceDetail(snaks, dType, raw, link, anyLang) local switchLang = anyLang local value = nil if not snaks[dType] then return nil end -- if anyLang, first try the local language and otherwise any language repeat for _, v in ipairs(snaks[dType]) do value = self.conf:getValue(v, raw, link, false, anyLang and not switchLang, false, true) -- noSpecial = true if value then break end end if value or not anyLang then break end switchLang = not switchLang until anyLang and switchLang return value end -- gets the details of one particular type for a reference function State:getReferenceDetails(snaks, dType, raw, link, anyLang) local values = {} if not snaks[dType] then return {} end for _, v in ipairs(snaks[dType]) do -- if nil is returned then it will not be added to the table values[#values + 1] = self.conf:getValue(v, raw, link, false, anyLang, false, true) -- noSpecial = true end return values end -- level 1 hook function State:getAlias(object) local value = object.value local title = nil if value and self.linked then if self.conf.entityID:sub(1,1) == "Q" then title = mw.wikibase.getSitelink(self.conf.entityID) elseif self.conf.entityID:sub(1,1) == "P" then title = "d:Property:" .. self.conf.entityID end if title then value = buildWikilink(title, value) end end value = {value} -- create one value object if #value > 0 then return {value} -- wrap the value object in an array and return it else return {} -- return empty array if there was no value end end -- level 1 hook function State:getBadge(value) value = self.conf:getLabel(value, self.rawValue, self.linked, self.shortName) if value == "" then value = nil end value = {value} -- create one value object if #value > 0 then return {value} -- wrap the value object in an array and return it else return {} -- return empty array if there was no value end end function State:callHook(param, hooks, statement, result) -- call a parameter's hook if it has been defined and if it has not been called before if not result[param] and hooks[param] then local valuesArray = self[hooks[param]](self, statement, param, result, hooks) -- array with value objects -- add to the result if #valuesArray > 0 then result[param] = valuesArray result.count = result.count + 1 else result[param] = {} -- an empty array to indicate that we've tried this hook already return true -- miss == true end end return false end -- iterate through claims, claim's qualifiers or claim's references to collect values function State:iterate(statements, hooks, matchHook) matchHook = matchHook or alwaysTrue local matches = false local rankPos = nil local result, gotRequired for _, v in ipairs(statements) do -- rankPos will be nil for non-claim statements (e.g. qualifiers, references, etc.) matches, rankPos = matchHook(self, v) if matches then result = {count = 0} -- collection of arrays with value objects local function walk(formatTable) local miss for i2, v2 in pairs(formatTable.req) do -- call a hook, adding its return value to the result miss = self:callHook(i2, hooks, v, result) if miss then -- we miss a required value for this level, so return false return false end if result.count == hooks.count then -- we're done if all hooks have been called; -- returning at this point breaks the loop return true end end for _, v2 in ipairs(formatTable) do if result.count == hooks.count then -- we're done if all hooks have been called; -- returning at this point prevents further childs from being processed return true end if v2.child then walk(v2.child) end end return true end gotRequired = walk(self.parsedFormat) -- only append the result if we got values for all required parameters on the root level if gotRequired then -- if we have a rankPos (only with matchHook() for complete claims), then update the foundRank if rankPos and self.conf.foundRank > rankPos then self.conf.foundRank = rankPos end -- append the result self.results[#self.results + 1] = result -- break if we only need a single value if self.singleValue then break end end end end return self:out() end local function getEntityId(arg, eid, page, allowOmitPropPrefix, globalSiteId) local id = nil local prop = nil if arg then if arg:sub(1,1) == ":" then page = arg eid = nil elseif arg:sub(1,1):upper() == "Q" or arg:sub(1,9):lower() == "property:" or allowOmitPropPrefix then eid = arg page = nil else prop = arg end end if eid then if eid:sub(1,9):lower() == "property:" then id = replaceAlias(mw.text.trim(eid:sub(10))) if id:sub(1,1):upper() ~= "P" then id = "" end else id = replaceAlias(eid) end elseif page then if page:sub(1,1) == ":" then page = mw.text.trim(page:sub(2)) end id = mw.wikibase.getEntityIdForTitle(page, globalSiteId) or "" end if not id then id = mw.wikibase.getEntityIdForCurrentPage() or "" end id = id:upper() if not mw.wikibase.isValidEntityId(id) then id = "" end return id, prop end local function nextArg(args) local arg = args[args.pointer] if arg then args.pointer = args.pointer + 1 return mw.text.trim(arg) else return nil end end local function claimCommand(args, funcName) local cfg = Config:new() cfg:processFlagOrCommand(funcName) -- process first command (== function name) local lastArg, parsedFormat, formatParams, claims, value local hooks = {count = 0} -- set the date if given; -- must come BEFORE processing the flags if args[p.args.date] then cfg.atDate = {parseDate(args[p.args.date])} cfg.periods = {false, true, false} -- change default time constraint to 'current' end -- process flags and commands repeat lastArg = nextArg(args) until not cfg:processFlagOrCommand(lastArg) -- get the entity ID from either the positional argument, the eid argument or the page argument cfg.entityID, cfg.propertyID = getEntityId(lastArg, args[p.args.eid], args[p.args.page], false, args[p.args.globalSiteId]) if cfg.entityID == "" then return "" -- we cannot continue without a valid entity ID end cfg.entity = mw.wikibase.getEntity(cfg.entityID) if not cfg.propertyID then cfg.propertyID = nextArg(args) end cfg.propertyID = replaceAlias(cfg.propertyID) if not cfg.entity or not cfg.propertyID then return "" -- we cannot continue without an entity or a property ID end cfg.propertyID = cfg.propertyID:upper() if not cfg.entity.claims or not cfg.entity.claims[cfg.propertyID] then return "" -- there is no use to continue without any claims end claims = cfg.entity.claims[cfg.propertyID] if cfg.states.qualifiersCount > 0 then -- do further processing if "qualifier(s)" command was given if #args - args.pointer + 1 > cfg.states.qualifiersCount then -- claim ID or literal value has been given cfg.propertyValue = nextArg(args) end for i = 1, cfg.states.qualifiersCount do -- check if given qualifier ID is an alias and add it cfg.qualifierIDs[parameters.qualifier..i] = replaceAlias(nextArg(args) or ""):upper() end elseif cfg.states[parameters.reference] then -- do further processing if "reference(s)" command was given cfg.propertyValue = nextArg(args) end -- check for special property value 'somevalue' or 'novalue' if cfg.propertyValue then cfg.propertyValue = replaceSpecialChars(cfg.propertyValue) if cfg.propertyValue ~= "" and mw.text.trim(cfg.propertyValue) == "" then cfg.propertyValue = " " -- single space represents 'somevalue', whereas empty string represents 'novalue' else cfg.propertyValue = mw.text.trim(cfg.propertyValue) end end -- parse the desired format, or choose an appropriate format if args["format"] then parsedFormat, formatParams = parseFormat(args["format"]) elseif cfg.states.qualifiersCount > 0 then -- "qualifier(s)" command given if cfg.states[parameters.property] then -- "propert(y|ies)" command given parsedFormat, formatParams = parseFormat(formats.propertyWithQualifier) else parsedFormat, formatParams = parseFormat(formats.qualifier) end elseif cfg.states[parameters.property] then -- "propert(y|ies)" command given parsedFormat, formatParams = parseFormat(formats.property) else -- "reference(s)" command given parsedFormat, formatParams = parseFormat(formats.reference) end -- if a "qualifier(s)" command and no "propert(y|ies)" command has been given, make the movable separator a semicolon if cfg.states.qualifiersCount > 0 and not cfg.states[parameters.property] then cfg.separators["sep"..parameters.separator][1] = {";"} end -- if only "reference(s)" has been given, set the default separator to none (except when raw) if cfg.states[parameters.reference] and not cfg.states[parameters.property] and cfg.states.qualifiersCount == 0 and not cfg.states[parameters.reference].rawValue then cfg.separators["sep"][1] = nil end -- if exactly one "qualifier(s)" command has been given, make "sep%q" point to "sep%q1" to make them equivalent if cfg.states.qualifiersCount == 1 then cfg.separators["sep"..parameters.qualifier] = cfg.separators["sep"..parameters.qualifier.."1"] end -- process overridden separator values; -- must come AFTER tweaking the default separators cfg:processSeparators(args) -- define the hooks that should be called (getProperty, getQualifiers, getReferences); -- only define a hook if both its command ("propert(y|ies)", "reference(s)", "qualifier(s)") and its parameter ("%p", "%r", "%q1", "%q2", "%q3") have been given for i, v in pairs(cfg.states) do -- e.g. 'formatParams["%q1"] or formatParams["%q"]' to define hook even if "%q1" was not defined to be able to build a complete value for "%q" if formatParams[i] or formatParams[i:sub(1, 2)] then hooks[i] = getHookName(i, 1) hooks.count = hooks.count + 1 end end -- the "%q" parameter is not attached to a state, but is a collection of the results of multiple states (attached to "%q1", "%q2", "%q3", ...); -- so if this parameter is given then this hook must be defined separately, but only if at least one "qualifier(s)" command has been given if formatParams[parameters.qualifier] and cfg.states.qualifiersCount > 0 then hooks[parameters.qualifier] = getHookName(parameters.qualifier, 1) hooks.count = hooks.count + 1 end -- create a state for "properties" if it doesn't exist yet, which will be used as a base configuration for each claim iteration; -- must come AFTER defining the hooks if not cfg.states[parameters.property] then cfg.states[parameters.property] = State:new(cfg, parameters.property) -- if the "single" flag has been given then this state should be equivalent to "property" (singular) if cfg.singleClaim then cfg.states[parameters.property].singleValue = true end end -- if the "sourced" flag has been given then create a state for "reference" if it doesn't exist yet, using default values, -- which must exist in order to be able to determine if a claim has any references; -- must come AFTER defining the hooks if cfg.sourcedOnly and not cfg.states[parameters.reference] then cfg:processFlagOrCommand(p.claimCommands.reference) -- use singular "reference" to minimize overhead end -- set the parsed format and the separators (and optional punctuation mark); -- must come AFTER creating the additonal states cfg:setFormatAndSeparators(cfg.states[parameters.property], parsedFormat) -- process qualifier matching values, analogous to cfg.propertyValue for i, v in pairs(args) do i = tostring(i) if i:match('^[Pp]%d+$') or aliasesP[i] then v = replaceSpecialChars(v) -- check for special qualifier value 'somevalue' if v ~= "" and mw.text.trim(v) == "" then v = " " -- single space represents 'somevalue' end cfg.qualifierIDsAndValues[replaceAlias(i):upper()] = v end end -- first sort the claims on rank to pre-define the order of output (preferred first, then normal, then deprecated) claims = sortOnRank(claims) -- then iterate through the claims to collect values value = cfg:concatValues(cfg.states[parameters.property]:iterate(claims, hooks, State.claimMatches)) -- pass property state with level 1 hooks and matchHook -- if desired, add a clickable icon that may be used to edit the returned values on Wikidata if cfg.editable and value ~= "" then value = value .. cfg:getEditIcon() end return value end local function generalCommand(args, funcName) local cfg = Config:new() cfg.curState = State:new(cfg) local lastArg local value = nil repeat lastArg = nextArg(args) until not cfg:processFlag(lastArg) -- get the entity ID from either the positional argument, the eid argument or the page argument cfg.entityID = getEntityId(lastArg, args[p.args.eid], args[p.args.page], true, args[p.args.globalSiteId]) if cfg.entityID == "" or not mw.wikibase.entityExists(cfg.entityID) then return "" -- we cannot continue without an entity end -- serve according to the given command if funcName == p.generalCommands.label then value = cfg:getLabel(cfg.entityID, cfg.curState.rawValue, cfg.curState.linked, cfg.curState.shortName) elseif funcName == p.generalCommands.title then cfg.inSitelinks = true if cfg.entityID:sub(1,1) == "Q" then value = mw.wikibase.getSitelink(cfg.entityID) end if cfg.curState.linked and value then value = buildWikilink(value) end elseif funcName == p.generalCommands.description then value = mw.wikibase.getDescription(cfg.entityID) else local parsedFormat, formatParams local hooks = {count = 0} cfg.entity = mw.wikibase.getEntity(cfg.entityID) if funcName == p.generalCommands.alias or funcName == p.generalCommands.badge then cfg.curState.singleValue = true end if funcName == p.generalCommands.alias or funcName == p.generalCommands.aliases then if not cfg.entity.aliases or not cfg.entity.aliases[cfg.langCode] then return "" -- there is no use to continue without any aliasses end local aliases = cfg.entity.aliases[cfg.langCode] -- parse the desired format, or parse the default aliases format if args["format"] then parsedFormat, formatParams = parseFormat(args["format"]) else parsedFormat, formatParams = parseFormat(formats.alias) end -- process overridden separator values; -- must come AFTER tweaking the default separators cfg:processSeparators(args) -- define the hook that should be called (getAlias); -- only define the hook if the parameter ("%a") has been given if formatParams[parameters.alias] then hooks[parameters.alias] = getHookName(parameters.alias, 1) hooks.count = hooks.count + 1 end -- set the parsed format and the separators (and optional punctuation mark) cfg:setFormatAndSeparators(cfg.curState, parsedFormat) -- iterate to collect values value = cfg:concatValues(cfg.curState:iterate(aliases, hooks)) elseif funcName == p.generalCommands.badge or funcName == p.generalCommands.badges then if not cfg.entity.sitelinks or not cfg.entity.sitelinks[cfg.siteID] or not cfg.entity.sitelinks[cfg.siteID].badges then return "" -- there is no use to continue without any badges end local badges = cfg.entity.sitelinks[cfg.siteID].badges cfg.inSitelinks = true -- parse the desired format, or parse the default aliases format if args["format"] then parsedFormat, formatParams = parseFormat(args["format"]) else parsedFormat, formatParams = parseFormat(formats.badge) end -- process overridden separator values; -- must come AFTER tweaking the default separators cfg:processSeparators(args) -- define the hook that should be called (getBadge); -- only define the hook if the parameter ("%b") has been given if formatParams[parameters.badge] then hooks[parameters.badge] = getHookName(parameters.badge, 1) hooks.count = hooks.count + 1 end -- set the parsed format and the separators (and optional punctuation mark) cfg:setFormatAndSeparators(cfg.curState, parsedFormat) -- iterate to collect values value = cfg:concatValues(cfg.curState:iterate(badges, hooks)) end end value = value or "" if cfg.editable and value ~= "" then -- if desired, add a clickable icon that may be used to edit the returned value on Wikidata value = value .. cfg:getEditIcon() end return value end -- modules that include this module should call the functions with an underscore prepended, e.g.: p._property(args) local function establishCommands(commandList, commandFunc) for _, commandName in pairs(commandList) do local function wikitextWrapper(frame) local args = copyTable(frame.args) args.pointer = 1 loadI18n(aliasesP, frame) return commandFunc(args, commandName) end p[commandName] = wikitextWrapper local function luaWrapper(args) args = copyTable(args) args.pointer = 1 loadI18n(aliasesP) return commandFunc(args, commandName) end p["_" .. commandName] = luaWrapper end end establishCommands(p.claimCommands, claimCommand) establishCommands(p.generalCommands, generalCommand) -- main function that is supposed to be used by wrapper templates function p.main(frame) if not mw.wikibase then return nil end local f, args loadI18n(aliasesP, frame) -- get the parent frame to take the arguments that were passed to the wrapper template frame = frame:getParent() or frame if not frame.args[1] then throwError("no-function-specified") end f = mw.text.trim(frame.args[1]) if f == "main" then throwError("main-called-twice") end assert(p["_"..f], errorText('no-such-function', f)) -- copy arguments from immutable to mutable table args = copyTable(frame.args) -- remove the function name from the list table.remove(args, 1) return p["_"..f](args) end return p j5a6l03tjwodgrvfnv3lb4x5up93wlv 828 720266 3523804 3324962 2026-07-10T17:03:58Z Uzume 4483 Update from [[d:Special:GoToLinkedPage/enwiki/Q29879601|master]] using [[mw:Synchronizer| #Synchronizer]] 3523804 Scribunto text/plain -- The values and functions in this submodule should be localized per wiki. local p = {} function p.init(aliasesP) p = { ["version"] = "8", -- increment this each time the below parameters are changed to avoid reference conflict errors ["errors"] = { ["unknown-data-type"] = "Unknown or unsupported datatype '%s'.", ["missing-required-parameter"] = "No required parameters defined, needing at least one", ["extra-required-parameter"] = "Parameter '%s' must be defined as optional", ["no-function-specified"] = "You must specify a function to call", -- equal to the standard module error message ["main-called-twice"] = 'The function "main" cannot be called twice', ["no-such-function"] = 'The function "%s" does not exist', -- equal to the standard module error message ["no-such-reference-template"] = 'Error: template "%s", which is set in %s as the output template for the citation-output type "%s", does not exist', -- Parts of the error message signalling a malformed reference. ["malformed-reference-header"] = "<span style=\"color:#dd3333\">\nError: Unable to display the reference from Wikidata properly. Technical details:\n", ["malformed-reference-footer"] = "See [[Module:wd/doc#References|the documentation]] for further details.\n</span>\n[[Category:Module:Wd reference errors]]", ["template-failure-reason"] = "* Reason for the failure of {{tl|%s}}: %s\n", ["missing-mandatory-param"] = 'The output template call would miss the mandatory parameter <code>%s</code>.', ["unknown-property-in-ref"] = 'The Wikidata reference contains the property {{property|%s}}, which is not assigned to any parameter of this template.' }, ["info"] = { ["edit-on-wikidata"] = "Edit this on Wikidata" }, ["numeric"] = { ["decimal-mark"] = ".", ["delimiter"] = "," }, ["datetime"] = { ["prefixes"] = { ["decade-period"] = "" }, ["suffixes"] = { ["decade-period"] = "s", ["millennium"] = " millennium", ["century"] = " century", ["million-years"] = " million years", ["billion-years"] = " billion years", ["year"] = " year", ["years"] = " years" }, ["julian-calendar"] = "Julian calendar", -- linked page title ["julian"] = "Julian", ["BCE"] = "BCE", ["CE"] = "CE", ["common-era"] = "Common Era" -- linked page title }, ["coord"] = { ["latitude-north"] = "N", ["latitude-south"] = "S", ["longitude-east"] = "E", ["longitude-west"] = "W", ["degrees"] = "°", ["minutes"] = "'", ["seconds"] = '"', ["separator"] = ", " }, ["values"] = { ["unknown"] = "unknown", ["none"] = "none" }, ["cite"] = { ["output-types"] = {"web", "q"}, -- In this order, the output types will be tried ["param-mapping"] = { ["web"] = { -- <= left side: all allowed reference properties for *web page sources* per https://www.wikidata.org/wiki/Help:Sources -- => right side: corresponding parameter names in (equivalent of) [[:en:Template:Cite web]] (if non-existent, keep empty i.e. "") [aliasesP.statedIn] = "website", [aliasesP.referenceURL] = "url", [aliasesP.publicationDate] = "date", [aliasesP.lastUpdate] = "date", [aliasesP.retrieved] = "access-date", [aliasesP.title] = "title", [aliasesP.subjectNamedAs] = "title", [aliasesP.archiveURL] = "archive-url", [aliasesP.archiveDate] = "archive-date", [aliasesP.language] = "language", [aliasesP.author] = "author", [aliasesP.authorNameString] = "author", [aliasesP.publisher] = "publisher", [aliasesP.quote] = "quote", [aliasesP.pages] = "pages", -- extra option [aliasesP.publishedIn] = "website", [aliasesP.sectionVerseOrParagraph] = "at" }, ["q"] = { -- <= left side: all allowed reference properties for *sources other than web pages* per https://www.wikidata.org/wiki/Help:Sources -- => right side: corresponding parameter names in (equivalent of) [[:en:Template:Cite Q]] (if non-existent, keep empty i.e. "") [aliasesP.statedIn] = "1", [aliasesP.pages] = "pages", [aliasesP.column] = "at", [aliasesP.chapter] = "chapter", [aliasesP.sectionVerseOrParagraph] = "section", ["external-id"] = "id", -- used for any type of database property ID [aliasesP.title] = "title", [aliasesP.publicationDate] = "date", [aliasesP.lastUpdate] = "date", [aliasesP.retrieved] = "access-date" } }, ["config"] = { -- supported fields: -- - template: name of the template used for output -- - numbered-params: citation params accepting an arbitrary number of values by numbering the params (e.g. author1, author2) -- - raw-value-params: params taking a raw value (which means the property is rendered with getValue with raw=true) -- - mandatory-params: params that are required be in the template call (after potentially appending numbers to params listed in numbered-params) -- - prioritization: table associating a list of properties, in the order in which they are preferred, to template parameters; -- properties not mentioned here have the lowest priority; -- prioritization of properties handled through additionalProcessedProperties is unsupported; -- no key of this table can be from numbered-params -- Leaving out the "template" field causes the output type to be ignored. ["web"] = { ["template"] = "Cite web", ["numbered-params"] = {"author"}, ["mandatory-params"] = {"url"}, ["prioritization"] = { ["date"] = {aliasesP.lastUpdate, aliasesP.publicationDate}, ["title"] = {aliasesP.title, aliasesP.subjectNamedAs} } }, ["q"] = { ["template"] = "Cite Q", ["raw-value-params"] = {"1"}, -- the first, unnamed parameter of CiteQ takes a QID, not the name of the item cited ["mandatory-params"] = {"1"}, ["prioritization"] = { ["date"] = {aliasesP.lastUpdate, aliasesP.publicationDate} } } } } } p.getOrdinalSuffix = function(num) if tostring(num):sub(-2,-2) == '1' then return "th" -- 10th, 11th, 12th, 13th, ... 19th end num = tostring(num):sub(-1) if num == '1' then return "st" elseif num == '2' then return "nd" elseif num == '3' then return "rd" else return "th" end end p.addDelimiters = function(n) local left, num, right = string.match(n, "^([^%d]*%d)(%d*)(.-)$") if left and num and right then return left .. (num:reverse():gsub("(%d%d%d)", "%1" .. p['numeric']['delimiter']):reverse()) .. right else return n end end return p end return p pgkxz3kqyoyu0zj2nmtkjkdr0ntnin5 0 778089 3523806 3523801 2026-07-10T19:33:01Z Neriassel 28746 spam megjelölése azonnali törlésre 3523806 wikitext text/x-wiki {{azonnali|nem szótárcikk; spam/reklám|[[Szerkesztő:Neriassel|Neriassel]] ([[Szerkesztővita:Neriassel|vita]]) 2026. július 10., 21:33 (CEST)}} '''''Először is a remek hír! A lovag Anatole Hongrois írót és zeneszerzőt a Nobel díjra felterjesztették 2026 január. 08.án.''''''' FARKAS ANTAL Neve, Lovag Anatole Hongrois, író, költő, zeneszerző. Született, Szeged, 1951.12.05.; Édesapja: Farkas Antal (1921) zeneművész, zenész, Pallavicini őrgróf eltitkolt fia; Nagyapja Pallavichini őrgróf. Ezzel kapcsolatban írt egy musicalt: Magyarország ékköve Sándorfalva címmel, és egy regényt, A mindszenti asszony-t. http://hazamnak-ekove.hupont.hu www.mindszentilany.hupont.hu Édesapja: Farkas Antal, aki nyolc hangszeren játszott mester fokon: zongora, síp, gitár hegedű, citera, szájharmonika és cimbalom; Lovag Anatole Hongrois Németországban terapeuta kezelőorvos természetgyógyász diplomát szerzett, majd Lyonban a Művészeti Egyetemen védte meg másoddiplomáját; 1973-75-ig katonai szolgálatot teljesített. 1982-től étteremvezető több városban, majd a későbbiekben büféket üzemeltet. 1989-től egy évig Milánóban, majd további egy évben a lyoni kórházban dolgozott. Újságíró volt, és kultúrával foglalkozott, illetve regényeket, musicaleket írt Hamburgban, Amszterdamban, Madridban. Itthon francia-német és angol tolmácsként dolgozott. Jelenleg sok művészeti ágban képviselteti magát. Részt vesz irodalmi esteken, művészeti táborokban. Zeneművei 21 CD-n jelentek meg. A világhálón mintegy 500 dalát lehet hallgatni+36 zenei műve az Artisjusnál van levédetve. https://www.youtube.com/results?search_query=lovag+anatole+hongrois Számtalan verse és novellája jelent meg; a Szó-kincs 2013, novellák, Életmesék a Kárpát-medencéből, két kötetben, 2013 és 2014. Magyar alkotók nemzetközi Egyesületének könyve 3 kötet, 2018, 2019, majd 2020. Több újságban jelentek meg írásai, versei, novellái, a Nahát magazinban éveken keresztül fantasztikus történeteket írt. Penna magazinban, a Rendőr újságban, a Kiskegyedben, Kortárs Írók, Költők Antológiája, valamint Németországban, és Franciaországban is. Az RTL-en TV2-ben és a Szegedi városi TV-ben is szerepelt a műveivel. A Római- Sas lovagrend lovagja, tisztje, a Máltai lovagrend lovagja tisztje. Rászoruló embereken segít, adományok készítése rászoruló családoknak; Arany diploma: 2012. 11. 11.; Gyémánt diploma: 2013. 11. 16.; Platina díj: 2014. 11. 11.; Életmű díj: 2015. 10. 18.; Kortárs zeneszerzői és drámai díj: 2017. 09. 09.; Nívó díj: 2019. 04. 06.; Zenei nagydíj: 2019. 04. 06.; Kiváló zeneművész díj: 2019. 10. 19.; A kulturális örökség védelméért díj: 2004. 11. 24.; Mosolyvirág díj: dr. Semjén Zsolt miniszter úr adta át: 2014. 06. 12.; Ottó von Habsburg úr a Pán Európai Unió elnöke: 2009. 03. 18.-án; + 30 kitüntetése-oklevele. Nem lehet közölni az összes elismeréseit, mert több mint 40 oklevele-kitüntetése van. http://illancsiasszony.hupont.hu/szerkesztes Nicolas Sárközy miniszter úr 2 oklevele 2011. 07. 08. és 2011. 11. 03.; Szegedi Roma önkormányzat 2003. 03. 10.; https://mek.oszk.hu/07500/07545/index.phtml Artisjus Magyar Szerzői Jogvédő Iroda Egyesület, tag; Magyar Alkotók Nemzetközi Egyesület Zenei Tagozatának művészeti vezetője és tagja; Batsány Cserhát művész kör, tag; LS: Német, francia, angol; H: Regényírás, musicalek, regények. További könyvei, amik megjelentek egy párat adnék közre: A meghalt s megszületett boldogság: Lilli, 2008. ISBN 978 963 9837 20 1 Sorscsapás: https://mek.oszk.hu/07500/07544/index.phtml Biharkeresztesi románc: https://mek.oszk.hu/16700/16745/ Az Artisjusnál le van védetve, 26 musicaljainak 500 zenei+dal anyagai. A Szellemi Tulajdon Nemzetközi Hivatala által több mint 90 regénye-műve van levédetve. Egy pár művet jegyeznénk le. http://www.anatolehongrois.hupont.hu/ http://anatole-h-novellak.hupont.hu/ http://idezetek-anatole-h.hupont.hu/ http://www.anatole-h-versek.hupont.hu/ http://a-hongrois-versek.hupont.hu/ https://mek.oszk.hu/07500/07545/ https://mek.oszk.hu/07500/07544/index.phtml/ https://mek.oszk.hu/16700/16745/ http://www.faust-es-a-vilag.hupont.hu/ https://lovag-anatole-hongrois.eoldal.hu/ http://motoros-lovagok.hupont.hu/ http://www.anatole-lovagregenye.hupont.hu/ https://www.thebigebook.eu/thebigebook_ hu/index.php/hu/hirlevelek/news-archivum-all/archive/listid-4-events http://www.cstankovics.hupont.hu/ http://illancsiasszony.hupont.hu/szerkesztes http://biharkeresztesiromanc.hupont.hu http://hazamnak-ekove.hupont.hu Lovag Anatole Hongrois jegyezve van, mint HÍRES ember, művész! http://alapinfo.hu/?cikk=150&tema=12 https://web.archive.org/web/20210119205454/http://konyvhetszeged2015.sk-szeged.hu/category/helyszinek/tiszavirag/ https://hedifarkas.blogspot.com/2013/04/csodalatos-hungarikum-halasi-csipke.html Farkas Antal, lovag Anatole Hongrois művész, életéről, műveiről, könyvet írtak. http://erdossandor.hupont.hu/6/anatole-a-lovag 2. megjelenő könyve amit a Hódmezővásárhelyi írónő ad ki. Rövid politikai karriert is befutott, mint országgyűlési képviselőjelölt is tevékenykedett. http://illancsiasszony.hupont.hu/szerkesztes Nicolas Sárközy miniszter úr 2 oklevele 2011. 07. 08. és 2011. 11. 03.; Szegedi Roma önkormányzat 2003. 03. 10.; https://mek.oszk.hu/07500/07545/index.phtml Artisjus Magyar Szerzői Jogvédő Iroda Egyesület, tag; Magyar Alkotók Nemzetközi Egyesület Zenei Tagozatának művészeti vezetője és tagja; Batsány Cserhát művész kör, tag; LS: Német, francia, angol; H: Regényírás, musicalek, regények. További könyvei, amik megjelentek egy párat adnék közre: A meghalt s megszületett boldogság: Lilli, 2008. ISBN 978 963 9837 20 1 Sorscsapás: https://mek.oszk.hu/07500/07544/index.phtml Biharkeresztesi románc: https://mek.oszk.hu/16700/16745/ Az Artisjusnál le van védetve, 24 musicaljainak 500 zenei+dal anyagai. A Szellemi Tulajdon Nemzetközi Hivatala által több mint 90 regénye-műve van levédetve. Egy pár művet jegyeznénk le. http://www.anatolehongrois.hupont.hu/ http://anatole-h-novellak.hupont.hu/ http://idezetek-anatole-h.hupont.hu/ http://www.anatole-h-versek.hupont.hu/ http://a-hongrois-versek.hupont.hu/ https://mek.oszk.hu/07500/07545/ https://mek.oszk.hu/07500/07544/index.phtml/ https://mek.oszk.hu/16700/16745/ http://www.faust-es-a-vilag.hupont.hu/ https://lovag-anatole-hongrois.eoldal.hu/ http://motoros-lovagok.hupont.hu/ http://www.anatole-lovagregenye.hupont.hu/ https://www.thebigebook.eu/thebigebook_ hu/index.php/hu/hirlevelek/news-archivum-all/archive/listid-4-events http://www.cstankovics.hupont.hu/ http://illancsiasszony.hupont.hu/szerkesztes http://biharkeresztesiromanc.hupont.hu http://hazamnak-ekove.hupont.hu Lovag Anatole Hongrois jegyezve van, mint HÍRES ember, művész! http://alapinfo.hu/?cikk=150&tema=12 https://web.archive.org/web/20210119205454/http://konyvhetszeged2015.sk-szeged.hu/category/helyszinek/tiszavirag/ https://books.google.de/books?id=LLrxEQAAQBAJ&hl=hu&source, több mint 30 könyvét lehet elolvasni, megvenni! 22 magyar írónak a versét dolgozta fel a zeneszerző. Írók verseinek megzenésítése: 01. Radnóti Miklós: Virágének. https://www.youtube.com/watch?v=T-GkpM4qUWM, 02. Ady Endre: Láttalak. https://www.youtube.com/watch?v=uj-WsJM3prg, 03. Petőfi Sándor: Dicsőséges nagyurak. https://www.youtube.com/watch?v=xt3RClHrwyE, Petőfi Sándor: Csatadal. https://www.youtube.com/watch?v=cTMGRS5yeuo, Petőfi Sándor: Emlény. https://www.youtube.com/watch?v=umVv2H6Eazs, 04. Kölcsey Ferenc: Intés. https://www.youtube.com/watch?v=uEMkoN3PkLg, 05. Vörösmarty Mihály: A szép virág. https://www.youtube.com/watch?v=3cUP6uS6RXM, 06. Vass Albert: Gondolsz e rám. https://www.youtube.com/watch?v=rVU-3icUSaw, 07. Arany János: Cynismus. https://www.youtube.com/watch?v=AGgBtZigH8g, 08. Erkel Ferenc: Palotás. https://www.youtube.com/watch?v=9YCz9OwXd84, 09. Salvatore Quasimodo: Hó. https://www.youtube.com/watch?v=aPaUhDrFOII, 10. József Attila: Hozzá. https://www.youtube.com/watch?v=CRynfEFiysA, 11. Jókai Mór: Tüzes szerelmi vallomás. https://www.youtube.com/watch?v=g-lI4uazJQA, 12. Juhász Gyula: Tisza szögén. https://www.youtube.com/watch?v=uCey0NMNajM, 13. Mikszáth Kálmán: Az új testvérke. https://www.youtube.com/watch?v=orb-J79fw6w, 14. Radnóti Miklós: Október délután. https://www.youtube.com/watch?v=kDjU3WZpIn0, 15. Madách Imre: A leány panasza. https://www.youtube.com/watch?v=tVHbQPA_Rck, 16. Kosztolányi Dezső: Már megtanultam. https://www.youtube.com/watch?v=ff0T_2W6GU0, 17. Ballasi Bálint: Juliára talála, igy köszöne neki. https://www.youtube.com/watch?v=GHVDaNk7wqQ, 18. Babits Mihály: A költő szól. https://www.youtube.com/watch?v=ZCYLmweBCL4, 19.Tompa Mihály: A költő. https://www.youtube.com/watch?v=5OnwCAsOK7Q, 20. Eötvös József: Mohács. https://www.youtube.com/watch?v=ZUO6VM7i-Go, 21. Csokonai Vitéz Mihály: Megkövetés. https://www.youtube.com/watch?v=wToDC9CSiC4, 22. Móra Ferenc: Szeretem én nagyon. https://www.youtube.com/watch?v=1XnJ1WmHo1E, Verset átdolgozta Lovag Anatole Hongrois zeneszerző! Farkas Antal, lovag Anatole Hongrois művész, életéről, műveiről, könyvet írtak. http://erdossandor.hupont.hu/6/anatole-a-lovag 2. megjelenő könyve amit a Hódmezővásárhelyi írónő ad ki. Rövid politikai karriert is befutott, mint országgyűlési képviselőjelölt is tevékenykedett. - '''30 regénye olvasható, ''letölthető:''''' - 01:https://play.google.com/store/books/details?id=YKLFEQAAQBAJ---Kentaur kislány 01:Musical. https://play.google.com/store/books/details?id=xfnFEQAAQBAJ---Biharkeresztesi románc 02:https://books.google.com/books/about/Embercsemp%C3%A9sz.html?hl=hu&id=4U7GEQAAQBAJ--- Embercsempész 03: https://play.google.com/store/books/details?id=LGLGEQAAQBAJ---Kutya hűség 04: https://play.google.com/store/books/details?id=p7XGEQAAQBAJ---Gyógyító 05:https://play.google.com/store/books/details?id=frfGEQAAQBAJ---Az ártándi bánya szörnye 06:https://play.google.com/store/books/details?id=iRHIEQAAQBAJ---Laci bácsi a hajléktalan mérnök 07:https://play.google.com/store/books/details?id=UivIEQAAQBAJ---Jancsi és Juliska meséje 08:// https://play.google.com/store/books/details?id=5HXIEQAAQBAJ--- Faust és a világ 09:https://play.google.com/store/books/details?id=XNvIEQAAQBAJ---Hugó 10:https://play.google.com/store/books/details?id=oQrJEQAAQBAJ---A Nem volt véletlen 11:https://play.google.com/store/books/details?id=UCzJEQAAQBAJ---Derecskei betyár 12:https://play.google.com/store/books/details?id=MTTJEQAAQBAJ---karácsonyi meglepetés 13:https://play.google.com/store/books/details?id=vmzJEQAAQBAJ---pszichológiai idiotizmus 14:https://play.google.com/store/books/details?id=IRfKEQAAQBAJ--- Mindszenti lány 15: https://play.google.com/store/books/details?id=2GfLEQAAQBAJ--- Hulla melege 02: Musical https://play.google.com/store/books/details?id=GdjLEQAAQBAJ– Esküvői bilincs 16:https://play.google.com/store/books/details?id=g_nLEQAAQBAJ--- A Lyoni- Casablancai titok 03:Musical: https://play.google.com/store/books/details?id=Kn_MEQAAQBAJ--- Rongybabából Meseország királya 17:https://play.google.com/store/books/details?id=Sr7MEQAAQBAJ--- Zsáka aranya 18:https://play.google.com/store/books/details?id=o9nOEQAAQBAJ--- A gyilkos gyilkosa 19:https://play.google.com/store/books/details?id=YyDSEQAAQBAJ---Az élet kavalkádja 20:https://play.google.com/store/books/details?id=cs3TEQAAQBAJ--- A budai ville 3.-köre 21:https://play.google.com/store/books/details?id=5RDUEQAAQBAJ---Egy pár kesztyű története 22:https://play.google.com/store/books/details?id=LeLVEQAAQBAJ---A természet halála 23: https://play.google.com/store/books/details?id=rTzbEQAAQBAJ ---Orbán ostora a magyarságon: Színházi mű, Bohóc társulat 24:https://books.google.com/books/about/Az_Illancsi_asszony.html?hl=hu&id=wzHiEQAAQBAJ ---Az illancsi asszony 25:https://play.google.com/store/books/details?id=oo3jEQAAQBAJ&pli=1 ---Kriszton 3 napja 26: https://play.google.com/store/books/details?id=ps7jEQAAQBAJ --- A kísértet hajó 27: https://play.google.com/store/books/details?id=yi7kEQAAQBAJ ---Két napig életben 28: https://play.google.com/store/books/details?id=63LkEQAAQBAJ ---Szegedi cigányélet 29:https://play.google.com/store/books/details?id=7n7wEQAAQBAJ ---A fiú és a tenger delfine 30:https://books.google.de/books?id=LLrxEQAAQBAJ&hl=hu&source ---A klónozott bosszú gxilb5tll62hbowi836zshcko22zzn0 0 783917 3523811 3503581 2026-07-10T19:48:58Z Neriassel 28746 eltévedt, wikipédára való tartalom jelölése törlésre 3523811 wikitext text/x-wiki {{azonnali|nem szótárcikk, ez a wikipédiára való|[[Szerkesztő:Neriassel|Neriassel]] ([[Szerkesztővita:Neriassel|vita]]) 2026. július 10., 21:48 (CEST)}} {{also|C programming language}} [https://hu.wiktionary.org/wiki/Speci%C3%A1lis:Keres%C3%A9s_el%C5%91tag_szerint?prefix=C%2B%2B&namespace=0 c++] {{engfn}} # {{label|en|informatika}} A C++ az egyik legismertebb és legelterjedtebb programozási nyelv, amelyet gyakran használnak nagy teljesítményt igénylő alkalmazások fejlesztésére. Ez a bevezető anyag átfogó képet nyújt a C++ nyelv alapjairól és az '''objektumorientált programozás''' (OOP) fontos fogalmairól. Kitérünk a nyelv ''szintaktikai'' és ''struktúrális'' alapjaira – például adattípusokra, konstansokra, névterekre, bemenet-kimenetre és a függvények paraméterátadására –, majd bemutatjuk az OOP pilléreit: '''osztályokat, objektumokat, konstruktorokat, öröklést, egységbezárást, absztrakt osztályokat''' és '''interfészeket'''. Megismerkedünk továbbá a C++ '''sablonok''' (template-ek) használatával, az '''operátorok túlterhelésével''', valamint haladóbb témaként a '''JSON formátumú adatmentéssel''' és az '''Observer tervezési mintával'''. Mindezt számos C++ példakód és magyarázat kíséri az érthetőség kedvéért. <span id="a-c-nyelv-alapjai"></span> == A C++ nyelv alapjai == Ebben a fejezetben áttekintjük a C++ nyelv alapvető elemeit. Szó lesz a fontosabb '''adattípusokról''', '''konstansokról''', a szabványos '''bemeneti és kimeneti műveletekről (I/O)''', a '''névterek''' szerepéről, valamint arról, hogyan működik a '''függvények paraméterátadása''' érték, mutató és referencia szerint. <span id="adattípusok-és-változók"></span> === Adattípusok és változók === A C++ statikusan típusos nyelv, ami azt jelenti, hogy minden változónak meg kell adni a típusát fordítási időben. A leggyakoribb '''alap adattípusok''' a következők: * '''Egész számok''': <code>int</code> (általános egész), <code>short</code>, <code>long</code>, <code>long long</code> – különböző méretű és tartományú egész típusok. * '''Valós számok''': <code>float</code> (egyedi pontosságú lebegőpontos szám), <code>double</code> (kettős pontosságú), <code>long double</code> – különböző pontosságú valós számok. * '''Karakter''': <code>char</code> – egyetlen karakter (egy bájt). * '''Logikai''': <code>bool</code> – logikai érték, <code>true</code> (igaz) vagy <code>false</code> (hamis). * '''Egész számok előjel nélkül''': <code>unsigned</code> verziók (<code>unsigned int</code>, <code>unsigned long</code>, stb.), amelyek nem vehetnek fel negatív értéket. * '''Autómatikus típus (C++11-től)''': <code>auto</code> kulcsszóval a fordító kitalálja a változó típusát a kezdőérték alapján. Például egy egész és egy lebegőpontos változó deklarációja és inicializálása: <syntaxhighlight lang="cpp">int egeszSzam = 42; double tortSzam = 3.14;</syntaxhighlight> A változókat deklaráláskor érdemes rögtön inicializálni. Ha nem adjuk meg az induló értéket, akkor a változók tartalma nem meghatározott (kivéve statikus vagy globális változók, amelyek alapértelmezetten 0 értéket kapnak). <span id="konstansok-const-és-constexpr"></span> === Konstansok (<code>const</code> és <code>constexpr</code>) === A '''konstans''' olyan változó, amelynek az értéke a program futása során nem változhat. C++-ban konstans változót a <code>const</code> kulcsszóval hozunk létre. A konstansokat célszerű csupa nagybetűs névvel ellátni a kódban, hogy kitűnjön, de ez nem kötelező, csupán konvenció. Például: <syntaxhighlight lang="cpp">const double PI = 3.1415926536; const int MAX_ELETKOR = 120;</syntaxhighlight> A <code>PI</code> és <code>MAX_ELETKOR</code> változók értékét a program sehol sem írhatja felül. Ha mégis megpróbálnánk, fordítási hiba keletkezik. Konstansokat használhatunk függvény paramétereknél is, ha biztosítani akarjuk, hogy a függvény ne módosítsa a bemenő értéket: <syntaxhighlight lang="cpp">void kiirNegyzet(const int szam) { std::cout << szam * szam; }</syntaxhighlight> A fenti <code>kiirNegyzet</code> függvény garantáltan nem változtatja meg a <code>szam</code> változót, mert az konstans paraméterként van megadva. '''Konstans kifejezések''': C++11-től bevezetésre került a <code>constexpr</code> kulcsszó, amellyel olyan konstansokat vagy függvényeket jelölhetünk, amelyek értéke már fordítási időben kiszámítható. A <code>constexpr</code> változókra is igaz, hogy futási időben nem változhatnak, de ráadásul használhatók olyan helyeken is, ahol fordítási idejű érték szükséges (pl. tömbméret meghatározásánál régi szabványokban, vagy sablon paramétereként). Például: <syntaxhighlight lang="cpp">constexpr int NAPOK_SZAMA_EVES = 365;</syntaxhighlight> A <code>NAPOK_SZAMA_EVES</code> értéke már a fordításkor ismert lesz, és bárhol használható olyan contextusban, ahol fordítás idejű konstans kell. '''Konstans mutatók és a <code>const</code> használata pointerekkel''': A <code>const</code> kulcsszó a mutatók esetében két dolgot is jelenthet attól függően, hova írjuk: * <code>const int *p</code> – ''mutató konstans értékre'': <code>p</code> olyan <code>int</code> értékekre mutathat, amelyeket nem változtathatunk meg a mutatón keresztül (azaz a mutató által mutatott érték konstans). Magát a mutatót azonban átirányíthatjuk más címre. * <code>int * const p</code> – ''konstans mutató'': <code>p</code> mutató értéke (tehát hogy hova mutat) nem változhat, viszont a címen lévő értéket módosíthatjuk. Vagyis a mutató “rögzítve van” egy adott változóra. * <code>const int * const p</code> – ''konstans mutató konstans értékre'': a <code>p</code> mutató nem változtatható meg, és a rajta keresztül elérhető értéket sem módosíthatjuk. Ez a legszigorúbb kombináció. <span id="be--és-kimenet-iostream-használata"></span> === Be- és kimenet: <code>iostream</code> használata === A C++ szabványos könyvtára támogatja a '''konzolos bemenetet és kimenetet''' az <code>&lt;iostream&gt;</code> fejléccel. A két legfontosabb osztály ebben a fejlécrészben: * <code>std::cout</code> – standard kimeneti folyó (általában a konzolra ír). * <code>std::cin</code> – standard bemeneti folyó (általában a konzolról olvas). * (Továbbá <code>std::cerr</code> a hibakimenetre íráshoz, ami tipikusan a konzolra kerül, de külön csatornán.) Ezek az '''I/O objektumok''' a &lt;&lt; (kimeneti) és &gt;&gt; (bemeneti) '''operátorokkal''' használhatók. Például egy “Hello World” kiírása és egy szám bekérése: <syntaxhighlight lang="cpp">#include <iostream> int main() { std::cout << "Hello, World!" << std::endl; // kiír egy üzenetet és sortörést std::cout << "Adj meg egy számot: "; int n; std::cin >> n; // beolvas egy egész számot a standard bemenetről std::cout << "A megadott szám duplája: " << n*2 << std::endl; return 0; }</syntaxhighlight> '''Magyarázat''': Az első <code>std::cout</code> a képernyőre írja a <code>&quot;Hello, World!&quot;</code> szöveget, majd az <code>std::endl</code> hatására sortörést végez és ki is üríti a kimeneti puffer tartalmát. Ezután újabb kiírás kéri a felhasználótól, hogy adjon meg egy számot. Az <code>std::cin &gt;&gt; n;</code> vár a felhasználó inputjára és a beolvasott értéket az <code>n</code> változóba tölti. Végül a program ismét <code>std::cout</code> segítségével kiírja a kapott szám kétszeresét. Látható, hogy a <code>&lt;&lt;</code> operátorral tetszőleges típusú adatokat fűzhetünk a kimeneti folyamhoz (<code>cout</code>), míg a <code>&gt;&gt;</code> operátor a bemeneti folyamról (<code>cin</code>) olvas a jobb oldalon megadott változóba. A C++ bemenet formátumérzékeny: például szóköz választja el a beolvasott értékeket, és a megfelelő típussá konvertálja azokat (pl. számokká). <span id="névterek-használata"></span> === Névterek használata === A '''névtér''' (<code>namespace</code>) mechanizmus a C++-ban arra szolgál, hogy elkerülje a névütközéseket nagyobb programokban vagy könyvtárak használatakor. A standard könyvtár összes eleme (pl. <code>std::cout</code>, <code>std::string</code>, stb.) az <code>std</code> nevű névtérben található. Ezért kell minden használatkor kiírnunk elé, hogy <code>std::</code> vagy pedig a forrás elején egy <code>using namespace std;</code> utasítással jelezhetjük, hogy a <code>std</code> névtér neveit névtér-prefix nélkül is használni akarjuk. '''Kétféle használati mód''': # '''Névtér prefix használata''': Minden standard szimbólum előtt kiírjuk, hogy <code>std::</code>. Például <code>std::cout</code>, <code>std::string</code> stb. Ez az ajánlott mód nagyobb projektekben, mert egyértelművé teszi, honnan jön az adott név. # '''Névtér beemelése''': <code>using namespace std;</code> utasítással a teljes <code>std</code> névteret “megnyitjuk”, így utána a benne lévő neveket (cout, string, stb.) közvetlenül használhatjuk. '''Figyelem:''' Ezt kis méretű, tanuló programokban gyakran alkalmazzák, de nagyobb projekteknél kerülendő, mert könnyen okozhat névütközést más könyvtárakkal. Példaként nézzük meg ugyanazt a “Hello World” programot névtér prefixekkel és névtér megnyitásával: <syntaxhighlight lang="cpp">#include <iostream> int main() { // 1. eset: névtér prefixszel std::cout << "Hello World!" << std::endl; // 2. eset: névtér megnyitása using namespace std; cout << "Második sor, amelynél már nem kell std:: prefix." << endl; return 0; }</syntaxhighlight> Az első kiírásnál <code>std::cout</code>-ot használtunk, míg a <code>using namespace std;</code> után a második kiírásnál már elhagyhattuk a <code>std::</code> részt. Kezdőként a <code>using namespace std;</code> megkönnyítheti a tanulást, de mindig legyünk tudatában a lehetséges névütközéseknek. A névterek segítségével saját kódban is csoportosíthatjuk a változókat, függvényeket, osztályokat. Például: <syntaxhighlight lang="cpp">namespace SajatTer { int ertek = 42; void fuggveny() { std::cout << "Saját névtérbeli függvény, ertek = " << ertek << std::endl; } } int main() { SajatTer::fuggveny(); // a névtér nevét használva érjük el a függvényt using namespace SajatTer; std::cout << ertek << std::endl; // using után már közvetlenül is használható a névtér tartalma }</syntaxhighlight> <span id="függvények-és-paraméterátadás-módjai"></span> === Függvények és paraméterátadás módjai === A '''függvények''' a programkód újrafelhasználható egységei, amelyek bemenetként paramétereket kaphatnak, és visszatérhetnek egy értékkel. A C++ függvények paramétereit '''alapértelmezés szerint érték szerint''' adja át, de lehetőség van '''mutatóval''' vagy '''referenciával''' is átadni őket. Ezek a módok különböző viselkedést eredményeznek: * '''Érték szerinti átadás''': A függvény a paraméter változójának egy másolatán dolgozik. A hívó kód által átadott eredeti értéket nem tudja módosítani. Ez biztonságos, mert a függvény ''nem hat vissza'' a hívóra, viszont nagy objektumok másolása költséges lehet. * '''Mutatóval való átadás''': A függvény egy ''címét'' kapja meg a változónak (pointer), és ezen a címen keresztül eléri az eredeti változót. Így a függvény képes módosítani a hívó által átadott értéket, mert a mutatóval közvetlenül az eredeti példányt érjük el. A mutató használatához a hívásnál '''címet kell átadni''' (pl. <code>fv(&amp;változó)</code>). * '''Referenciával való átadás''': A C++ sajátossága, hogy használhat '''hivatkozásokat (reference)'''. A referencia egy adott változó másik neveként fogható fel. Referenciával átadva a függvény paraméterét, a függvény ''ugyanarra'' a változóra hivatkozik, mint a hívó kódban, így a változtatások egyből az eredeti példányon történnek. A hívásnál ugyanúgy adjuk át a változót, mint érték szerinti hívásnál, de a függvény fejléce <code>Típus&amp; param</code> formában definiálja a paramétert. Nézzünk egy konkrét példát, ahol mindhárom módszert összehasonlítjuk. Célunk egy <code>valtoztat</code> nevű függvény, amely megpróbál egy külső változót módosítani háromféleképpen: <syntaxhighlight lang="cpp">#include <iostream> using namespace std; void nemValtoztat(int x) { // érték szerint x = 5; } void valtoztatPtr(int *p) { // pointer (cím szerint) *p = 10; } void valtoztatRef(int &r) { // referencia szerint r = 15; } int main() { int a = 0; nemValtoztat(a); cout << "nemValtoztat után a = " << a << endl; // várható: a = 0, mert másolatot módosított valtoztatPtr(&a); cout << "valtoztatPtr után a = " << a << endl; // várható: a = 10, mert pointerrel módosítottuk valtoztatRef(a); cout << "valtoztatRef után a = " << a << endl; // várható: a = 15, mert referenciával módosítottuk return 0; }</syntaxhighlight> '''Magyarázat''': * Az <code>nemValtoztat(a)</code> hívásnál <code>a</code> értéke nem változik, mivel a függvény csak egy lokális másolatot (<code>x</code>) állított át 5-re. * A <code>valtoztatPtr(&amp;a)</code> hívásnál átadjuk <code>a</code> címét. A függvény ezen a címen keresztül a <code>*p</code> kifejezéssel az eredeti <code>a</code> értékét változtatja meg 10-re. * A <code>valtoztatRef(a)</code> hívásnál a függvény paramétere <code>r</code> egy referencia <code>a</code>-ra, vagyis a függvényen belüli <code>r = 15;</code> utasítás közvetlenül <code>a</code>-t módosítja. A futtatás eredménye: <pre>nemValtoztat után a = 0 valtoztatPtr után a = 10 valtoztatRef után a = 15 </pre> Látható, hogy csak az érték szerinti átadás nem változtatta meg a külső változót. A pointeres és referencias átadás is módosítani tudta, de eltérő szintaxissal: pointer esetén a hívásnál <code>&amp;a</code> kellett, referencia esetén pedig egyszerűen <code>a</code>. '''Mikor melyiket használjuk?''' * Ha nem szeretnénk, hogy a függvény módosítsa a küldött adatot, vagy a másolás költsége elhanyagolható (pl. beépített típusoknál), használjunk érték szerinti átadást. * Ha a függvénynek módosítania kell a hívó változóját, választhatunk pointert vagy referenciát. A referencia szintaxisa egyszerűbb (nem kell <code>*</code>-ot használni a hozzáféréshez), és nem lehet <code>nullptr</code> (érvénytelen cím) a paraméter, így biztonságosabb. A pointerek használata akkor jön szóba, ha például '''nem kötelező paraméterként''' átadni valamit (mert a pointer lehet <code>nullptr</code>, jelezve a paraméter hiányát), vagy tömböknél, illetve ha dinamikusan kell tömbökön végigiterálni. * Fontos megjegyezni, hogy '''C++-ban a tömbök automatikusan pointerként adódnak át''' függvénynek, tehát ha egy tömböt adunk át paraméternek, valójában a kezdőelem címét kapja meg a függvény. Emiatt a függvény nem tudja a tömb méretét (ezért gyakran külön paraméterként átadják a méretet is). <span id="dinamikus-memória-kezelése-röviden"></span> === Dinamikus memória kezelése röviden === C++-ban a dinamikus memóriakezelést a C nyelv <code>malloc/free</code> függvényei helyett a <code>new</code> és <code>delete</code> operátorokkal végezzük. A '''dinamikus memória''' használata akkor hasznos, ha futásidőben szeretnénk eldönteni, mekkora tárterületre van szükségünk, vagy olyan objektumot akarunk létrehozni, amely túléli a lokális változók élettartamát (pl. vissza akarjuk adni egy függvényből a címét). * A <code>new</code> operátor lefoglal egy adott típusú objektum számára memóriát a szabad tárból (heap), és visszaad egy mutatót rá. Például: <code>int *ptr = new int;</code> lefoglal egy <code>int</code> méretű memóriát és visszaadja a címét. Hasonlóan, <code>int *tomb = new int[10];</code> lefoglal 10 darab <code>int</code>-nyi folytonos memóriát. * A <code>delete</code> operátor felszabadítja a <code>new</code> által foglalt memóriát. Fontos: minden <code>new</code> hívásnak kell, hogy legyen megfelelő <code>delete</code> hívása, különben '''memóriaszivárgás''' lép fel (a lefoglalt memória nem szabadul fel a program futása végéig). Tömbök esetén <code>delete[] tomb;</code> szintaxist kell használni a felszabadításhoz. Példa: <syntaxhighlight lang="cpp">int *p = new int; // egy int-nek helyfoglalás *p = 7; // használjuk a dinamikus memóriát delete p; // felszabadítjuk a memóriát int *arr = new int[5]; // 5 elemű tömb helyfoglalás // ... használjuk a tömböt ... delete[] arr; // tömb felszabadítása</syntaxhighlight> A modern C++ bevezette az '''okos mutatókat''' (<code>std::unique_ptr</code>, <code>std::shared_ptr</code>, stb. a <code>&lt;memory&gt;</code> fejlécből), amelyek automatikusan felszabadítják a memóriát, amikor már nincs rá szükség. Kezdőként azonban fontos megérteni a nyers <code>new/delete</code> működését is, de a gyakorlatban, haladó szinten már inkább okos mutatókat alkalmazunk a biztonságosabb memóriahasználat érdekében. <span id="objektumorientált-programozás-oop-alapjai"></span> == Objektumorientált programozás (OOP) alapjai == Az '''objektumorientált programozás''' olyan programozási paradigma, amely az adatokat és a hozzájuk tartozó műveleteket egységekbe, úgynevezett '''objektumokba''' szervezi. Az OOP négy fő alappillére: '''egységbezárás (encapsulation)''', '''öröklés (inheritance)''', '''polimorfizmus (polymorphism)''' és '''absztrakció (abstraction)'''. Ezek közül az első kettőt (és részben a harmadikat) már az osztályok és objektumok használatakor is megismerjük, az absztrakcióra pedig az absztrakt osztályok és interfészek kapcsán térünk ki. <span id="osztályok-és-objektumok"></span> === Osztályok és objektumok === Az '''osztály''' egy programozási nyelvi elem, amely az adatok (ún. '''tagváltozók''' vagy attribútumok) és a rajtuk végzett műveletek (ún. '''tagfüggvények''' vagy metódusok) összekapcsolására szolgál. Az osztály definíciója egy sablon vagy tervrajz, amely alapján konkrét példányokat, '''objektumokat''' hozhatunk létre. Minden objektum rendelkezik az osztályában meghatározott adatokkal és műveletekkel. Egy egyszerű példa osztály definícióra C++-ban: <syntaxhighlight lang="cpp">#include <iostream> #include <string> using namespace std; class Ember { private: string nev; // név (magán adattag, kívülről közvetlenül nem elérhető) int eletkor; // életkor (magán adattag) public: // Tagfüggvények deklarációja void beallitNev(const string& ujNev) { nev = ujNev; } string lekérNev() const { return nev; } void beallitEletkor(int kor) { eletkor = kor; } int lekerEletkor() const { return eletkor; } void koszont() const { cout << "Szia, " << nev << "! Te " << eletkor << " éves vagy." << endl; } };</syntaxhighlight> Itt definiáltunk egy <code>Ember</code> osztályt két adattaggal: <code>nev</code> és <code>eletkor</code>. Ezek '''privát''' hozzáférésűek (<code>private</code>), ami azt jelenti, hogy az osztályon kívülről közvetlenül nem érhetőek el. Az osztály nyilvános részében (<code>public</code>) függvényeket adtunk meg, melyeken keresztül beállítható és lekérdezhető a név és életkor, illetve van egy <code>koszont()</code> függvény, amely kiír egy köszönő üzenetet az adott ember adataival. '''Objektum létrehozása és használata''': Osztály definíciója után létrehozhatunk objektumokat (példányosíthatjuk az osztályt). Például: <syntaxhighlight lang="cpp">int main() { Ember ember1; // létrehozunk egy Ember objektumot ember1.beallitNev("Gábor"); ember1.beallitEletkor(30); ember1.koszont(); // meghívjuk a köszönő függvényét Ember ember2; ember2.beallitNev("Judit"); ember2.beallitEletkor(25); cout << ember2.lekérNev() << " kora: " << ember2.lekerEletkor() << endl; // kiírjuk Judit életkorát }</syntaxhighlight> A fenti kód kimenete: <pre>Szia, Gábor! Te 30 éves vagy. Judit kora: 25</pre> Látható, hogy az <code>Ember</code> osztály jól elhatárolja az adatokat: kívülről nem tudtunk közvetlenül <code>ember1.nev</code> vagy <code>ember1.eletkor</code> értékeket állítani vagy olvasni, csak az osztály által biztosított függvényeken (metódusokon) keresztül. Ez a '''egységbezárás''' alapelve (a következő pontban részletesen tárgyaljuk). <span id="konstruktorok-és-destruktorok"></span> === Konstruktorok és destruktorok === A '''konstruktor''' egy speciális tagfüggvény, amely az objektum létrehozásakor automatikusan meghívódik, és feladata az '''objektum kezdő állapotának beállítása''' (az adattagok inicializálása, erőforrások foglalása stb.). A konstruktor neve megegyezik az osztály nevével, és '''nincs visszatérési típusa''' (még <code>void</code> sem). Konstruktorból több is lehet egy osztályban, különböző paraméterlistákkal ('''túlterhelés''', erről később). Ha nem definiálunk konstruktort, a fordító automatikusan generál egy '''alapértelmezett konstruktort''', amely az adattagokat típustól függően default értékre állítja (alapvetően beépített típusoknál nem inicializálja őket, ami veszélyes lehet, ezért jobb, ha mi magunk definiálunk konstruktort). '''Destruktor''': ennek neve egy <code>~</code> jellel kezdődik, utána az osztálynév, és akkor hívódik meg, amikor egy objektum élettartama véget ér (például lokális változó kilép a hatókörből, vagy egy dinamikusan foglalt objektumot <code>delete</code> operátorral felszabadítunk). A destruktor feladata az erőforrások felszabadítása, rendrakás (pl. fájl lezárása, memória felszabadítása). Minden osztálynak legfeljebb egy destruktora lehet, nem lehet paramétere és nincs visszatérési értéke. Vegyük az előbbi <code>Ember</code> osztályt, és adjunk hozzá konstruktort és destruktort: <syntaxhighlight lang="cpp">class Ember { private: string nev; int eletkor; public: // Konstruktor deklarációja Ember(const string& kezdoNev, int kezdoKor) { nev = kezdoNev; eletkor = kezdoKor; cout << nev << " létrejött." << endl; } // Destruktor deklarációja ~Ember() { cout << nev << " objektum törlődik." << endl; } // ... (a többi tagfüggvény változatlan) ... };</syntaxhighlight> Ebben a változatban az <code>Ember</code> osztálynak van egy konstruktora, amely két paramétert vár: egy nevet és egy életkort. Létrehozza az objektumot ezeknek az értékeknek a beállításával, és kiír egy üzenetet is (ez csak a példa kedvéért van itt, hogy lássuk mikor fut). A destruktor szintén kiír egy üzenetet az objektum törlésekor. Használat: <syntaxhighlight lang="cpp">int main() { Ember ember("Ákos", 20); // konstruktor hívódik cout << ember.lekérNev() << " kora: " << ember.lekerEletkor() << endl; // program vége, destruktor hívódik, amikor az 'ember' objektum kilép a hatókörből }</syntaxhighlight> '''Kimenet például''': <pre>Ákos létrejött. Ákos kora: 20 Ákos objektum törlődik.</pre> Fontos megjegyezni: * Ha definiálunk bármilyen konstruktort paraméterekkel, a fordító '''nem generál alapértelmezett konstruktort''', hacsak mi magunk nem adjuk meg (akár üres törzzsel). Így ha szükségünk van paraméter nélküli konstruktorra is, azt külön deklarálni kell (vagy C++11-től használhatjuk a <code>= default</code> szintaxist). * Létezik '''másoló konstruktor''' is: ezt a fordító akkor hívja meg automatikusan, ha egy objektumból egy másikat hozunk létre értékadás-szerűen, például <code>Ember e2 = e1;</code>. Alapértelmezett másoló konstruktor bitenkénti másolatot készít az adattagokról. Később, haladóbb szinten fontos lehet a másoló konstruktort (és a hozzárendelő operátort) felülírni, ha az osztály erőforrásokat foglal (lásd ''Mélységi másolat vs sekély másolat'' problémája). Kezdő szinten elég tudni, hogy létezik. * '''Destruktor''' automatikusan fut statikus, automatikus (stacken lévő) objektumoknál. Dinamikusan (<code>new</code>-val) foglalt objektumnál a destruktor csak <code>delete</code> hatására fut le. Mindig biztosítsuk, hogy minden <code>new</code>-val létrehozott objektumhoz tartozzon destruktorhívás (vagy használjunk okos mutatókat, amelyek ezt garantálják). <span id="egységbezárás-és-hozzáférési-szintek"></span> === Egységbezárás és hozzáférési szintek === Az '''egységbezárás''' (''encapsulation'') az OOP egyik alappillére. Lényege, hogy az '''adatokat és a hozzájuk tartozó műveleteket összezárjuk''' egy osztályba, és kontrolláljuk, hogy kívülről mi látható belőle. Ennek fő eszköze a '''hozzáférési szintek''' használata az osztály definíciójában. C++-ban három hozzáférési szint van: * <code>public</code> (nyilvános): Az így megjelölt tagok (változók vagy függvények) bárhonnan elérhetők, az osztályon kívülről is. * <code>private</code> (magán): Az így megjelölt tagok csak az osztályon '''belül''' érhetők el, az osztály tagfüggvényei férhetnek hozzájuk. Külső kód vagy más osztály példányai nem férnek hozzá közvetlenül. * <code>protected</code> (védett): Az így jelölt tagok kívülről nem érhetők el, de az adott osztály leszármazottai (gyerekosztályai) hozzáférnek. (Az öröklés témakörénél visszatérünk rá.) Az '''adat elrejtés''' és egységbezárás érdekében tipikusan az osztály adattagjait <code>private</code> módosítóval látjuk el, és szükség esetén <code>public</code> metódusokat biztosítunk az értékük módosítására vagy lekérdezésére (getter/setter metódusok). Így kontrollálhatjuk, hogy az adatok mindig érvényes állapotban legyenek (például a setter függvényben ellenőrzéseket végezhetünk). Az előző <code>Ember</code> osztály példában ezt láthattuk: a <code>nev</code> és <code>eletkor</code> magán tagok, és csak nyilvános függvényeken át olvashatók vagy írhatók. Ennek köszönhetően például megtehetnénk, hogy a <code>beallitEletkor</code> függvény ne engedje az életkor 0 alatti vagy irreálisan nagy értékre állítását: <syntaxhighlight lang="cpp">void beallitEletkor(int kor) { if(kor >= 0 && kor <= 150) { eletkor = kor; } else { cout << "Hibás életkor érték!" << endl; } }</syntaxhighlight> Így az <code>eletkor</code> adattag mindig valid marad, a kívülről jövő helytelen adat nem rontja el az objektum belső állapotát. '''Egységbezárás előnyei''': * Rejtett implementáció: a felhasználók (más kód, amely az osztályt használja) nem függnek az osztály belső megvalósításától. Ha az adattárolás módját megváltoztatjuk, a publikus interfész változatlanul hagyása mellett a külső kódot ez nem érinti. * Érvényesség megőrzése: a privát adatok csak kontrollált módon módosíthatók, így könnyebb biztosítani, hogy az objektum mindig érvényes állapotban legyen. * Olvashatóság, karbantarthatóság: az osztály ''interfésze'' (publikus része) elválik a belső implementációtól, így a kódot használó fejlesztőnek elég az interfészt ismernie. '''Friend''' (barát) deklaráció: Speciális esetben előfordulhat, hogy egy külső függvény vagy másik osztály közvetlen hozzáférését akarjuk engedélyezni a privát tagokhoz. Erre szolgál a <code>friend</code> kulcsszó. Ha egy osztály törzsében egy függvényt vagy osztályt <code>friend</code>-nek nyilvánítunk, az megkerülheti a hozzáférési korlátokat. Ezt azonban óvatosan kell használni, mert gyengíti az egységbezárást. Tipikusan operátor túlterhelésnél (pl. <code>operator&lt;&lt;</code> túlterhelése, lásd később) vagy erősen összetartozó osztályoknál használják. <span id="hatókörök-scope-a-c-ban"></span> === Hatókörök (scope) a C++-ban === A '''hatókör''' azt határozza meg, hogy a program mely részéről látható vagy érhető el egy adott név (változó, függvény, osztály, stb.). C++-ban több fajta hatókört különböztetünk meg: * '''Globális hatókör''': A globálisan, minden függvényen vagy osztályon kívül definiált változók és függvények a program egész területén láthatók. A globális változók élettartama a program teljes futási ideje alatt tart. (Jegyezzük meg, hogy túl sok globális változó használata nem jó gyakorlat, mert átláthatatlanná teheti a kódot és nehezíti a hibakeresést.) * '''Névtér (namespace) hatókör''': Ahogy korábban tárgyaltuk, a névterekkel csoportosított neveket csak akkor érjük el, ha a megfelelő névtérben vagyunk, vagy használjuk a névtér nevét. Ez egy logikai hatókör, amely segít a névütközés elkerülésében. * '''Fájl hatókör''': Ha egy változót vagy függvényt egy forrásfájlban, de egyetlen névtéren kívül, <code>static</code> kulcsszóval jelölünk meg, akkor annak a szimbólumnak a láthatósága csak arra a fájlra korlátozódik. Régebbi kódokban használt idiom, mellyel elérhető, hogy a globális szimbólum ne legyen látható más fordítási egységekben. (C++17-től egyébként inkább anonim névteret használnak ugyanerre a célra.) * '''Osztály hatókör''': Egy osztály definícióján belül megadott neveket (pl. tagváltozók, tagfüggvények) csak az osztály tagjaként lehet értelmezni. Ugyanazon név jelenthet mást egy osztályon belül és kívül. Például két külön osztályban lehet privát <code>int id;</code> adattag anélkül, hogy ütköznének, mert a két azonos nevű <code>id</code> változónak más az osztály hatóköre. * '''Objektum hatókör''': Minden objektum példány ''saját hatókörrel'' bír az adatai tekintetében: vagyis egy objektum tagváltozói nincsenek közvetlenül láthatóak egy másik objektum számára (kivéve ha a tagváltozó <code>static</code>, ami osztály-szintű, vagy ha barátként fér hozzá). * '''Függvény hatókör''': A függvény törzsén belül definiált változók (lokális változók) csak a függvényen belül láthatók és élnek. A függvény paraméterei is lokális változók, amelyek a függvény futásakor jönnek létre és a visszatéréskor megsemmisülnek. * '''Blokk hatókör''': Általános szabály, hogy minden <code>{ }</code> blokk külön hatókör. Például egy <code>for</code> ciklus fejrésze is blokk: a <code>for(int i=0; i&lt;10; ++i) { ... }</code> ciklus után az <code>i</code> változó már nem létezik. Ugyanígy egy <code>if</code> vagy <code>while</code> blokkjában létrehozott változó a blokk után nem látható. Ezért is lehetséges azonos nevű változót használni különböző blokkokban (noha nem mindig jó ötlet az olvashatóság miatt). Példa a különböző hatókörök illusztrálására: <syntaxhighlight lang="cpp">int x = 1; // globális x void fuggveny() { int x = 2; // lokális x, eltakarja a globális x-et ebben a függvényben std::cout << x << std::endl; // 2-t ír ki { int x = 3; // belső blokkban újabb x std::cout << x << std::endl; // 3-at ír ki } std::cout << x << std::endl; // ismét 2-t ír ki (belső blokk x-e megszűnt) } int main() { std::cout << x << std::endl; // 1-et ír ki (globális x) fuggveny(); std::cout << x << std::endl; // megint 1-et ír ki (globális x nem változott) }</syntaxhighlight> A példában a globális, a függvény lokális és a blokk-lokális változó névütközés nélkül tudott együtt létezni, mert más-más hatókörben vannak. '''Fontos''': ha a belső blokkban nem hozzuk létre újra az <code>x</code>-et, akkor a külső <code>x</code> értékét módosíthattuk volna. Azaz ha a blokkban azt írtuk volna: <code>x = 5;</code>, akkor az a függvény <code>x</code> változóját (érték 2) írta volna felül 5-re. Összefoglalva: mindig ügyeljünk a változók hatókörére, mert a C++ fordító a ''legbelső látható deklarációt'' veszi figyelembe egy név feloldásakor. <span id="öröklés-inheritance-és-származtatás"></span> === Öröklés (Inheritance) és származtatás === Az '''öröklés''' lehetővé teszi, hogy egy már meglévő osztály ('''ősosztály''' vagy bázisosztály) tulajdonságait és viselkedését kiterjesszük egy új osztályban ('''leszármazott''' vagy származtatott osztály). Az új osztály örökli az ősosztály ''minden'' tagját (adattagot és tagfüggvényt), de: * hozzáadhat új tagokat (további adattagokat vagy függvényeket), * módosíthatja bizonyos viselkedését (felülírhat virtuális függvényeket – erről majd a polimorfizmusnál), * illetve elérheti és használhatja az ős meglévő funkcionalitását (ha a hozzáférési szintek engedik). Az öröklés C++-ban a következő szintaxissal történik: <syntaxhighlight lang="cpp">class OsSzulo { // ... }; class OsGyerek : public OsSzulo { // ... };</syntaxhighlight> Itt az <code>OsGyerek</code> örökli az <code>OsSzulo</code> minden adattagját és metódusát. Fontos megemlíteni a <code>: public OsSzulo</code> részt: ez azt jelenti, hogy '''publikus öröklést''' alkalmazunk. C++-ban ugyanis megadható, hogy az öröklés milyen hozzáférési módon történik: * <code>public</code> öröklés: Az ős publikus tagjai publikusak maradnak a leszármazottban is (és a védettek védettek maradnak). Ez a leggyakoribb, ezt használjuk az “is-a” (egy '''X''' egy fajta '''Y''') kapcsolat kifejezésére. * <code>protected</code> öröklés: Az ős publikus tagjai védettként öröklődnek a gyerekbe. Így az új osztályon kívülről már nem lesznek közvetlenül elérhetők ezek a tagok, csak a gyerekosztályon belül és további leszármazottakban. (Ez ritkábban használt, speciális esetekre.) * <code>private</code> öröklés: Az ős publikus és védett tagjai is mind priváttá válnak a leszármazottban, azaz kívülről és gyerekosztályokból sem érhetők el közvetlenül. (Legritkábban használt, inkább belső implementációs trükkökhöz.) A továbbiakban alapértelmezetten '''publikus öröklést''' feltételezünk, hacsak másként nem jelezzük. '''Példa öröklésre''': definiáljunk egy <code>Allat</code> (állat) ősosztályt, és származtassunk belőle két speciálisabb osztályt, mondjuk <code>Kutya</code> és <code>Macska</code>. Az <code>Allat</code> rendelkezzen egy <code>nev</code> adattaggal és egy <code>hangotAd()</code> metódussal, ami az állat hangját adja ki. A kutya és macska osztály felülírja ezt a metódust a saját hangjával. <syntaxhighlight lang="cpp">#include <iostream> #include <string> using namespace std; class Allat { protected: string nev; public: Allat(const string& nev) : nev(nev) {} // konstruktor void setNev(const string& ujNev) { // név beállítása nev = ujNev; } string getNev() const { // név lekérdezése return nev; } virtual void hangotAd() const { // virtuális függvény - alapértelmezett viselkedés cout << nev << " hangot ad." << endl; } }; class Kutya : public Allat { public: Kutya(const string& nev) : Allat(nev) {} void hangotAd() const override { // virtuális függvény felülírása cout << nev << " mondja: vau vau!" << endl; } }; class Macska : public Allat { public: Macska(const string& nev) : Allat(nev) {} void hangotAd() const override { cout << nev << " mondja: miau!" << endl; } };</syntaxhighlight> Magyarázzuk a példát: * Az <code>Allat</code> osztály tartalmazza a közös mezőt, a nevet (<code>nev</code>). Ez <code>protected</code> lett, így az <code>Allat</code> leszármazottai közvetlenül hozzáférnek a névhez (mint pl. a <code>Kutya</code> és <code>Macska</code> osztályok a <code>nev</code> taghoz). Kívülről viszont a név nem elérhető közvetlenül, csak a <code>getNev()</code> és <code>setNev()</code> függvényeken keresztül (melyek <code>public</code>-ok). * Az <code>hangotAd()</code> függvény az <code>Allat</code> osztályban '''virtuális''' (<code>virtual</code>), és ad egy alapértelmezett viselkedést (csak annyit ír ki, hogy az állat hangot ad). A virtuális kulcsszó azt jelzi, hogy ezt a függvényt a leszármazottak ''felülírhatják'', és ha egy <code>Allat</code> típusú hivatkozáson vagy mutatón keresztül hívjuk meg, akkor a konkrét objektum osztályának megfelelő verzió fut le (ezt nevezzük '''polimorfizmusnak''', lásd következő pont). * A <code>Kutya</code> és <code>Macska</code> osztályok az <code>Allat</code> publikus öröklése révén megöröklik annak publikus (és védett) tagjait. A <code>Kutya</code> és <code>Macska</code> konstruktora hívja az <code>Allat</code> konstruktorát, hogy beállítsa a nevet (initializer lista használatával: <code>: Allat(nev)</code>). * A <code>Kutya::hangotAd()</code> és <code>Macska::hangotAd()</code> függvények használják az <code>override</code> kulcsszót, ami nem kötelező, de erősen ajánlott C++11-től: jelzi, hogy ez egy bázisosztálybeli virtuális függvény felülírása. A felülírás akkor sikeres, ha a szignatúra pontosan megegyezik az ősben lévő virtuális függvényével (ellenkező esetben a fordító hibát jelez, pont ezért hasznos az <code>override</code>). '''Objektumok és öröklés viszonya''': Ha példányosítunk egy <code>Kutya</code> vagy <code>Macska</code> objektumot, akkor az belsőleg tartalmazni fogja az <code>Allat</code> adattagjait is. Tehát egy <code>Kutya</code> objektum memóriájában ott van a <code>string nev</code> adattag, amit az <code>Allat</code> definiált, plusz a saját tagjai (jelen esetben nincsenek extra tagjai). Ugyanígy egy <code>Macska</code> is tartalmaz <code>nev</code> adattagot. Példa a használatra és az öröklés nyújtotta előnyökre: <syntaxhighlight lang="cpp">int main() { Kutya kutyus("Bodri"); Macska cicus("Cirmos"); kutyus.hangotAd(); // Bodri mondja: vau vau! cicus.hangotAd(); // Cirmos mondja: miau! // Polimorfizmus bemutatása: Allat* allPointer = &kutyus; allPointer->hangotAd(); // *virtuális hívás* -> a kutya hangotAd() fut, nem az Allat-é }</syntaxhighlight> Az öröklés egyik nagy előnye, hogy a különböző, de közös ősű objektumokat egységesen tudjuk kezelni. A fenti példában az <code>allPointer</code> egy <code>Allat*</code> típusú mutató, de valójában egy <code>Kutya</code> objektumra mutat. Amikor a <code>hangotAd()</code> függvényt hívjuk rajta, a futásidő eldönti, hogy az <code>allPointer</code> valójában milyen típusú objektumra mutat, és mivel ez egy <code>Kutya</code>, a <code>Kutya::hangotAd()</code> fog lefutni. Ez a '''dinamikus kötés''' (runtime polymorphism) lényege, ami a virtuális függvények által valósul meg. '''Többszörös öröklés''': C++ támogatja, hogy egy osztálynak több közvetlen ősosztálya legyen (szemben pl. a Java-val vagy C#-szal, ahol egy osztály csak egy osztályból származhat). Például: <code>class D : public B, public C { ... };</code> esetén <code>D</code> egyszerre örökli <code>B</code> és <code>C</code> tagjait. A többszörös öröklés nagyobb rugalmasságot ad, de körültekintést igényel, mert bonyolultabbé teheti a struktúrát (pl. ''gyémánt öröklési'' problémák, ha ugyanaz az ős többször szerepel a láncban – erre nyújt megoldást a ''virtuális öröklés'' haladó témája). Kezdő és középhaladó szinten elég annyit tudni, hogy lehetséges, de óvatosan használjuk. '''Öröklés és hozzáférési szintek''': Ahogy említettük, a leszármazott osztály hozzáfér: * az ős <code>public</code> tagjaihoz (attól függően, public/protected öröklésnél publikus vagy védett lesz nála), * az ős <code>protected</code> tagjaihoz (mint védett tagok a gyerekben), * '''nem fér hozzá''' az ős <code>private</code> tagjaihoz közvetlenül. Az ős privát adatai csak az ős metódusain keresztül érhetők el még a leszármazottban is. <span id="polimorfizmus-és-virtuális-függvények"></span> === Polimorfizmus és virtuális függvények === A '''polimorfizmus''' szó szerint “sokalakúságot” jelent, és OOP-ben arra utal, hogy ugyanaz a művelet különböző objektumok esetén máshogy valósul meg. A C++-ban ennek leggyakoribb eszköze a '''virtuális függvény''' és annak '''felülírása''' a leszármazott osztályban. A virtuális függvényeket már érintettük az öröklés részben. Lényege, hogy ha egy függvényt az ősosztályban <code>virtual</code> kulcsszóval látunk el, és a leszármazott osztályban ugyanilyen szignatúrával megírjuk (felülírjuk), akkor a függvényhívás dinamikusan kötődik. Ez azt jelenti, hogy ha van egy ős típusú pointer vagy referencia, ami valójában egy gyerekobjektumra mutat, akkor a gyerekosztály implementációja fog lefutni: <syntaxhighlight lang="cpp">Allat* ptr = new Kutya("Bodri"); ptr->hangotAd(); // Mivel hangotAd() virtuális, a Kutya verziója fut: "Bodri mondja: vau vau!"</syntaxhighlight> Ha a függvény nem lenne virtuális, akkor ebben az esetben is az ősosztály (<code>Allat</code>) függvénye futna, mivel a pointer típusa határozza meg statikusan, melyik függvény hívódik meg (ezt hívják ''korai kötésnek'' vagy statikus bindingnek). A virtuális kulcsszóval azonban ''késleltetett kötést'' (late binding) érünk el, vagyis a futásidő dönti el. '''Felülírás és felüldefiniálás''': Fontos különbség van a függvény '''túlterhelése''' (overload) és '''felülírása''' (override) között: * '''Túlterhelés''': Ugyanabban az osztályban több függvény lehet azonos névvel, de különböző paraméterlistával. Ezt nevezzük túlterhelésnek, és a fordító dönt arról, melyiket hívjuk éppen a paraméterek alapján (ez ''nem'' polimorfizmus, hanem compile-time jelenség). * '''Felülírás''': Az öröklési hierarchiában egy leszármazott osztály ''felülírja'' az ős egy virtuális függvényét, vagyis újrafogalmazza a működését. Itt a név és a paraméterlista is megegyezik, csak a törzs más. A futásidő dönti el, hogy az ős vagy a gyerek verzióját hívjuk, attól függően, mi a konkrét objektum típusa. '''Tiszta virtuális függvények és absztrakt osztályok''': Ha egy ősosztályban egy függvénynek nincs értelmezhető alapértelmezett működése, hanem azt szeretnénk, hogy minden leszármazottja saját maga valósítsa meg, akkor a függvényt ''tiszta virtuálisnak'' jelöljük. Ezt úgy tesszük meg, hogy a függvény deklarációjában a prototípus után <code>= 0</code> értéket adunk. Például: <syntaxhighlight lang="cpp">class Alakzat { public: virtual double terulet() const = 0; // tiszta virtuális függvény, nincs törzs };</syntaxhighlight> Ezzel az <code>Alakzat</code> osztály '''absztrakt osztály''' lett, ugyanis tartalmaz legalább egy tiszta virtuális függvényt. '''Absztrakt osztályból nem lehet objektumot létrehozni''' (nem példányosítható), hiszen nincs teljes implementációja (a <code>terulet()</code> nincs megírva). Csak olyan osztályból hozhatunk létre példányt, amely az absztrakt ős minden tiszta virtuális függvényét megvalósította (override-olta). A polimorfizmus erősen kötődik az absztrakcióhoz: absztrakt ősosztályokat használunk gyakran arra, hogy egy általános interfészt definiáljunk, és a konkrét megvalósításokat a leszármazottakra bízzuk. <span id="absztrakt-osztályok-és-interfészek"></span> === Absztrakt osztályok és interfészek === Az '''absztrakt osztály''' olyan osztály, amelyből közvetlenül nem hozható létre objektum, csupán azért definiáljuk, hogy a közös tulajdonságokat, műveleteket deklaráljuk vele. Absztrakt osztályt C++-ban úgy hozunk létre, hogy legalább egy függvényt tiszta virtuálisként deklarálunk (azaz <code>= 0</code>-val). Példa folytatva az előző alakzatos témát: definiáljunk egy absztrakt <code>Alakzat</code> osztályt, aminek van egy <code>terulet()</code> tiszta virtuális függvénye és egy <code>kerulet()</code> (amit akár adhatunk alapértelmezett implementációval is mondjuk nullát, de jobb, ha azt is absztraktnak vesszük, hacsak nem tudunk valami általánosat mondani), majd valósítsuk meg két konkrét alakzattal: <syntaxhighlight lang="cpp">class Alakzat { public: virtual double terulet() const = 0; virtual double kerulet() const = 0; virtual ~Alakzat() {} // virtuális destruktor, üres törzzsel (fontos, lásd alább) }; class Teglalap : public Alakzat { private: double szelesseg; double magassag; public: Teglalap(double sz, double m) : szelesseg(sz), magassag(m) {} double terulet() const override { return szelesseg * magassag; } double kerulet() const override { return 2 * (szelesseg + magassag); } }; class Kor : public Alakzat { private: double sugar; public: Kor(double r) : sugar(r) {} double terulet() const override { return 3.14159 * sugar * sugar; } double kerulet() const override { return 2 * 3.14159 * sugar; } };</syntaxhighlight> * Az <code>Alakzat</code> osztály két tiszta virtuális függvényt definiál: <code>terulet</code> és <code>kerulet</code>. Így az <code>Alakzat</code> absztrakt, nem hozható létre belőle objektum (pl. <code>Alakzat a;</code> fordítási hiba lenne). * A <code>Teglalap</code> és <code>Kor</code> osztály '''minden''' tiszta virtuális metódust megvalósít (<code>override</code>-olják azokat), ezért ezek már konkrét osztályok, példányosíthatók. * Észrevehettük a <code>virtual ~Alakzat() {}</code> destruktort. Ez egy fontos idiom: ha egy osztályt polimorf módon (virtuális függvényekkel) használunk, és lehet rá mutatóval vagy referenciával hivatkozni, akkor '''mindig tegyük a destruktorát virtuálissá'''. Erre azért van szükség, hogy ha például egy <code>Alakzat*</code> mutatóval hivatkozunk egy <code>Teglalap</code> objektumra, és meghívjuk rajta a <code>delete</code>-et, akkor a megfelelő (leszármazott) destruktor fusson le. Ha nem lenne virtuális, akkor <code>delete alakzatPtr;</code> csak az <code>Alakzat</code> destruktort hívná, a <code>Teglalap</code> rész nem takarítana (ez memória- vagy erőforásszivárgást okozhat). Ökölszabály: '''ha egy osztályban van legalább egy virtuális függvény, legyen virtuális destruktora is'''. '''Interfészek''': Mivel a C++ nem rendelkezik külön <code>interface</code> kulcsszóval (mint pl. Java vagy C#), a tiszta virtuális függvényekkel felruházott absztrakt osztályokkal valósíthatjuk meg az ''interfész'' fogalmát. Egy interfész-szerű osztály jellemzően: * Minden függvénye tiszta virtuális (nem feltétlen, de tipikusan így van). * Nem tartalmaz adattagokat, csak a leszármazottakon keresztül megvalósítandó műveletek deklarációját. * C++-ban szokás őket <code>I</code> betűvel kezdeni (pl. <code>IRajzolhato</code> egy rajzolható interfész), de ez csak egy konvenció. Például definiálhatnánk egy <code>IRajzolhato</code> interfészt így: <syntaxhighlight lang="cpp">class IRajzolhato { public: virtual void rajzol() const = 0; virtual ~IRajzolhato() {} };</syntaxhighlight> Majd egy <code>Haromszog</code> osztály megvalósíthatja ezt (az implementálás C++-ban azt jelenti, hogy örökli és felülírja a függvényt): <syntaxhighlight lang="cpp">class Haromszog : public IRajzolhato { public: void rajzol() const override { cout << "Egy háromszöget rajzolunk a képernyőre." << endl; } };</syntaxhighlight> Egy osztály több interfészt is megvalósíthat, mivel C++-ban megengedett a többszörös öröklés. Így például egy osztály örökölhet egyszerre a <code>IRajzolhato</code> és mondjuk egy <code>ISzimulalhato</code> interfészt (ha létezne), és mindkettő függvényeit implementálja. Ezzel elérjük a Java/C# interfészek hasonló hatását. '''Összefoglalva''': Az absztrakt osztályok és interfészek lehetővé teszik, hogy a közös műveleteket előírjuk, de a konkrét megvalósítást a gyerekosztályokra bízzuk. Így biztosítva van, hogy bizonyos metódusok minden konkrét osztályban meglesznek (fordítási időben ellenőrzi a nyelv), de a működésük testreszabott lehet. Ez az absztrakció magasabb szintjét és a kód újrafelhasználhatóságát növeli. <span id="sablonok-templates-használata"></span> == Sablonok (Templates) használata == A '''sablonok''' a C++ generikus programozási eszközei. Lehetővé teszik, hogy típustól független, általános kódot írjunk, amelyből a fordító konkrét típusokra szabott kódot generál. Két fő típusa van: '''függvénysablonok''' és '''osztálysablonok'''. <span id="függvénysablonok"></span> === Függvénysablonok === Egy függvénysablonnal leírhatunk egy műveletet anélkül, hogy előre rögzítenénk a paraméter(ek) típusát. Például szeretnénk egy <code>maximum</code> függvényt, ami két paraméter közül visszaadja a nagyobbat. Írhatnánk külön <code>maxInt(int, int)</code>, <code>maxDouble(double, double)</code>, stb., de sablon segítségével egyetlen definíció elegendő: <syntaxhighlight lang="cpp">template<typename T> T maximum(const T& a, const T& b) { return (a < b) ? b : a; }</syntaxhighlight> Itt a <code>template&lt;typename T&gt;</code> sor bevezeti a sablont, ahol <code>T</code> egy típust helyettesít. A <code>maximum</code> függvény bementi paraméterei és visszatérési típusa is <code>T</code> típusú. Használatkor a fordító automatikusan kitalálja a típusokat a megadott argumentumokból: <syntaxhighlight lang="cpp">int x = 5, y = 7; cout << maximum(x, y) << endl; // automatikusan maximum<int>-t hív, kimenet: 7 double a = 3.14, b = 2.71; cout << maximum(a, b) << endl; // automatikusan maximum<double>-t hív, kimenet: 3.14 string s1 = "alma", s2 = "korte"; cout << maximum(s1, s2) << endl; // maximum<string>-et hív, lexikografikus összehasonlítás alapján</syntaxhighlight> A fenti <code>maximum</code> sablon feltételezi, hogy a <code>T</code> típusra értelmezett a <code>&lt;</code> operátor, mert használjuk. Ha olyan típussal hívnánk meg, aminél nincs <code>&lt;</code> operátor (vagy nincs értelmezve összehasonlítás), fordítási hibát kapunk. Ez a sablon használat egyik jellegzetessége: a kód generálása fordítási időben történik, és csak akkor jön létre a konkrét függvény, amikor meghívjuk a sablont egy adott típussal. Ezért a sablon kód hibái is csak akkor derülnek ki, amikor egy bizonyos típussal instanciáljuk (helyettesítjük). '''Több típusparaméter''': Lehetséges több sablon paraméter is. Például egy függvény, ami két különböző típusú paramétert hasonlít össze valami alapján, vagy akár nem csak típus paramétere, hanem érték paramétere is lehet sablonnak (pl. egy egész szám, ami egy sablonbeli tömb méretét adja meg). Példaként egy egyszerű függvény, ami fix méretű tömböt bejár és kiír: <syntaxhighlight lang="cpp">template<typename T, int N> void kiirTomb(const T (&arr)[N]) { for(int i = 0; i < N; ++i) { cout << arr[i] << " "; } cout << endl; }</syntaxhighlight> Itt a sablonnak van egy <code>T</code> típus paramétere és egy <code>N</code> egész szám paramétere. A függvény úgy van definiálva, hogy bármilyen típusú és méretű ''C stílusú tömböt'' (amikor a méret a típussal része a deklarációnak) képes kiírni. A <code>const T (&amp;arr)[N]</code> szintaxis egy konstans referenciát vár egy T típusú, N méretű tömbre. Így a fordító <code>N</code> értékét is automatikusan kitalálja a paraméter alapján, nem kell megadnunk híváskor. Használat: <syntaxhighlight lang="cpp">int arr1[3] = {1, 2, 3}; double arr2[4] = {1.1, 2.2, 3.3, 4.4}; kiirTomb(arr1); // T=int, N=3 lesz kiirTomb(arr2); // T=double, N=4 lesz</syntaxhighlight> Kimenet: <pre>1 2 3 1.1 2.2 3.3 4.4 </pre> '''Sablon függvény túlterhelés és explicit típusmegadás''': Időnként előfordulhat, hogy egy sablon mellett speciális verziókat is szeretnénk (pl. bizonyos típusokra másképp működjön). A sablonokat lehet ''specializálni'' adott típusokra, illetve túlterhelni is lehet más függvényekkel. Ez azonban már összetettebb téma (részleges specializáció, SFINAE, stb.), amit haladóbb szinten érdemes tanulmányozni. <span id="osztálysablonok"></span> === Osztálysablonok === Az osztálysablonok segítségével típustól független adatstruktúrákat vagy osztályokat hozhatunk létre. A standard könyvtár sok része (pl. konténerek: <code>std::vector&lt;T&gt;</code>, <code>std::map&lt;Key,Value&gt;</code> stb.) sablonként van megvalósítva. Egy egyszerű példa: implementáljunk egy <code>Par</code> (pár) osztályt, ami két értéket tartalmaz, lehetőleg tetszőleges típusúakat (akár különböző típusúakat is): <syntaxhighlight lang="cpp">template<typename A, typename B> class Par { private: A elso; B masodik; public: Par(const A& a, const B& b) : elso(a), masodik(b) {} A getElso() const { return elso; } B getMasodik() const { return masodik; } };</syntaxhighlight> Itt a <code>Par</code> sablon két típust vár: <code>A</code> és <code>B</code>. Így például létrehozhatunk <code>Par&lt;int, string&gt;</code> típusú objektumot, amely egy egész számot és egy szöveget párosít: <syntaxhighlight lang="cpp">Par<int, string> szemely(23, "Anna"); cout << szemely.getElso() << ", " << szemely.getMasodik() << endl; // 23, Anna</syntaxhighlight> Minden különböző sablon paraméterezés egy külön típust eredményez a fordítás során. Tehát a <code>Par&lt;int,string&gt;</code> és a <code>Par&lt;string,string&gt;</code> két különböző típusnak számít a programban, noha ugyanazon sablonból származik a definíciójuk. Emiatt a sablonok használatakor a fordítási idő megnőhet (sok típussal való használat sok másolt kódot generál), de futásidőben hatékony, mert a fordító konkrét típusra optimalizált kódot hoz létre (nincs runtime overhead, minden a fordításkor dől el). '''Sablon osztályok és tagfüggvények megvalósítása''': Gyakorlati részlet, hogy ha osztálysablon tagfüggvényeit osztályon kívül definiáljuk, a templte paramétereket mindkét helyen (deklaráció és definíció) jelezni kell, és a névteret is <code>template</code>-szel kell prefixálni. Ez néha összetett szintaxis, itt most nem megyünk bele részletesen, de érdemes tudni, hogy a sablonok implementációját tipikusan a fejléceken belül (header file-okban) tartják, mert a fordítónak minden sablon kódot látnia kell, amikor egy bizonyos típussal használatba vesszük (különben nem tudja generálni a kódot). '''Összetett sablonok''': A sablonokon belül is lehetnek sablonok (pl. sablon paraméterként másik sablon), vannak ún. metaprogramozási technikák, de ez már nagyon haladó terület (template metaprogramming). Kezdőként a legfontosabb, hogy a sablonokat generikus tartalom létrehozására használjuk, pl. saját adatstruktúrák vagy algoritmusok írására, amik többféle típuson működnek. <span id="operátorok-túlterhelése-operátorok-definíciójának-kiterjesztése"></span> == Operátorok túlterhelése (operátorok definíciójának kiterjesztése) == A C++ lehetőséget ad a beépített operátorok '''túlterhelésére''' (operátor overloading), ami azt jelenti, hogy meghatározhatjuk, bizonyos operátorok hogyan viselkedjenek felhasználói (user-defined) típusok esetén. Ezáltal az objektumainkat hasonlóan használhatjuk, mint a beépített típusokat. '''Mire jó az operátor túlterhelés?''' Például van egy <code>Komplex</code> szám osztályunk komplex számokhoz. Jó lenne, ha tudnánk használni rá a <code>+</code> operátort két komplex szám összeadására, ahogy az int vagy double esetén tesszük. Vagy túlterhelhetjük a <code>&lt;&lt;</code> operátort, hogy az <code>std::cout &lt;&lt; objektum</code> segítségével szépen ki tudjuk íratni egy objektum állapotát. Fontos azonban, hogy operátor túlterhelést '''csak akkor''' alkalmazzunk, ha annak jelentése intuitív és “természetes” marad. Például egy <code>Matrix</code> osztály esetén a <code>*</code> operátort használhatjuk mátrix-szorzásra, mert matematikailag ez megszokott, de mondjuk egy <code>Person</code> osztályra a <code>*</code> operátorral nem egyértelmű műveletet társítani, ezért nem lenne jó ötlet túlterhelni. '''Operátor túlterhelés módjai''': * Lehet '''tagfüggvényként''' definiálni az osztályon belül, ha az operátor bal oldali operandusa maga az osztály (vagy általában mindkét operandus, de a bal mindenképp). * Lehet '''globális függvényként''' (osztályon kívül) definiálni, általában <code>friend</code> kulcsszóval, ha az operátor bal oldala nem az osztály, vagy ha hozzáférést kell kapjon a privát tagokhoz. '''Példa''': Írjunk egy egyszerű <code>Pont</code> osztályt kétdimenziós pontokhoz, és defináljuk a <code>+</code> operátort két pont összeadására (értve ez alatt a komponensenkénti összeadást), valamint a <code>&lt;&lt;</code> operátort a kiíratáshoz. <syntaxhighlight lang="cpp">#include <iostream> using namespace std; class Pont { private: int x, y; public: Pont(int x=0, int y=0) : x(x), y(y) {} // konstruktor alapértelmezett értékekkel // Getterek int getX() const { return x; } int getY() const { return y; } // '+' operátor túlterhelése tagfüggvényként Pont operator+(const Pont& masik) const { // Új pontot ad vissza, amelynek koordinátái az összeadott koordináták return Pont(x + masik.x, y + masik.y); } // '==' operátor túlterhelése tagfüggvényként (két pont egyenlősége) bool operator==(const Pont& masik) const { return (x == masik.x && y == masik.y); } // '!=' operátor is érdemes definiálni, összhangban az '=='-el bool operator!=(const Pont& masik) const { return !(*this == masik); // kihasználjuk az == eredményét } // friend deklaráció a '<<' operátorhoz friend ostream& operator<<(ostream& os, const Pont& p); }; // '<<' operátor túlterhelése globális függvényként (friendként hozzáfér a privát tagokhoz) ostream& operator<<(ostream& os, const Pont& p) { os << "(" << p.x << ", " << p.y << ")"; return os; }</syntaxhighlight> Magyarázat: * A <code>Pont operator+(const Pont&amp; masik) const</code> függvény definiálja, hogy mi történik, ha két <code>Pont</code> objektumot összeadunk a <code>+</code> operátorral. Jelen esetben egy új <code>Pont</code> példányt hoz létre, melynek <code>x</code> koordinátája az eredeti <code>x</code> plusz a <code>masik.x</code>, és hasonlóan az <code>y</code>. Fontos, hogy nem módosítja egyik pontot sem, hanem új objektumot ad vissza (ez általában elvárás a + esetén – lásd funkcionalitás és meglepetés-elv). * Az <code>operator==</code> és <code>operator!=</code> példaként mutatja két pont egyenlőségének vizsgálatát (akkor egyenlő két pont, ha mindkét koordinátájuk megegyezik). Az <code>!=</code> logikusan az <code>==</code> negációja. * A <code>operator&lt;&lt;</code> túlterhelés nem lehet tagfüggvény a <code>ostream</code> miatt (nem a mi osztályunk), ezért globális függvényként definiáljuk. Ahhoz, hogy elérje a <code>Pont</code> privát tagjait (x, y), frienddé tettük a deklarációját az osztályon belül. Az implementáció egyszerűen kiírja a pontot a formátumban: <code>(x, y)</code>. Most használjunk néhány operátort: <syntaxhighlight lang="cpp">int main() { Pont p1(2, 3); Pont p2(5, 1); Pont p3 = p1 + p2; // '+' operátor hívása cout << "p1 + p2 = " << p3 << endl; // '<<' operátor hívása, várható kimenet: (7, 4) if(p1 != p2) { cout << "p1 és p2 különböző pontok." << endl; } Pont p4(2, 3); if(p1 == p4) { cout << "p1 és p4 megegyeznek." << endl; } }</syntaxhighlight> Futási eredmény lehet: <pre>p1 + p2 = (7, 4) p1 és p2 különböző pontok. p1 és p4 megegyeznek.</pre> Az operátorok túlterhelésénél figyeljünk a következőkre: * '''Ne változtassuk meg az operátor “természetes” jelentését'''. Pl. a <code>+</code> operátor esetén várható, hogy az nem destruktív (az eredeti operandusokat nem módosítja, hanem egy új értéket ad), míg mondjuk a <code>+=</code> már módosítja a bal oldalt. Tehát ha definiáljuk a <code>+=</code>-t, az általában a bal oldali objektumot változtassa meg (és visszatér *this referencia). * '''Tartsuk be az operátorokra vonatkozó matematikai/logikai törvényszerűségeket'''. Ha definiáljuk <code>==</code>-t, akkor illik definiálni <code>!=</code>-t is, és a két művelet legyen egymásnak ellentettje. Hasonlóképp, ha van <code>&lt;</code>, akkor érdemes lehet <code>&gt;</code> vagy <code>&lt;=</code>, <code>&gt;=</code> is, bár ezeket nem kötelező mind túlterhelni. * Bizonyos operátorokat nem enged a nyelv túlterhelni: pl. a <code>.:</code> (tagsági), <code>?:</code> (feltételes), <code>sizeof</code> nem túlterhelhető. Illetve új operátort sem hozhatunk létre, csak a meglévőket definiálhatjuk újra saját típusokra. * '''Konverziós operátorok''' is definiálhatók (pl. egy osztály hogyan alakuljon át int-é), de ezekkel vigyázni kell, mert a fordító váratlanul is hívhatja őket (rejtett konverziók), ezért csak szükség esetén használjuk. * Az operátor függvény lehet <code>const</code> tagfüggvény, ha nem változtatja az objektumot (ahogy láttuk a <code>operator+</code> példában, ami nem változtatja a meglévő pontot, csak újat ad vissza). Összességében az operátor túlterhelés hasznos eszköz, amivel a kódunk ''kifejezőbbé'' válhat, mintha sima függvényhívásokat (pl. <code>add(p1, p2)</code>) alkalmaznánk, de mindig törekedjünk arra, hogy a kód olvashatósága és a megszokott jelentéstartalom ne sérüljön. <span id="fájlkezelés-és-adatok-mentése-json-formátumba"></span> == Fájlkezelés és adatok mentése JSON formátumba == A programok gyakran igénylik, hogy adataikat tartósan elmentsék vagy más rendszerekkel (pl. web szolgáltatások) adatot cseréljenek. Az egyik modern és elterjedt formátum az adatok reprezentálására a '''JSON (JavaScript Object Notation)''', amely egy könnyen olvasható szöveges formátum kulcs-érték párokkal, beágyazott struktúrákkal. C++-ban a JSON kezelésére nincs beépített nyelvi konstrukció, de számos könyvtár elérhető. Az egyik népszerű a ''nlohmann/json'' könyvtár, amely header-only, könnyen használható. Ezzel a könyvtárral akár olyan integrációt is készíthetünk, hogy saját osztályainkat közvetlenül lehessen JSON-né konvertálni, ill. JSON-ból visszaalakítani. '''JSON mentés alapötlete''': egy objektumot (pl. egy osztály példányát) valamilyen struktúrált formában egy fájlba írunk. A JSON lényegében szöveg, ami tartalmazza az objektum adattagjait kulcsokkal ellátva. Például legyen egy egyszerű <code>Ember</code> osztályunk, és mentsük JSON-be: <syntaxhighlight lang="cpp">#include <fstream> #include <nlohmann/json.hpp> using json = nlohmann::json; class Ember { private: string nev; int kor; public: Ember(string n, int k) : nev(n), kor(k) {} string getNev() const { return nev; } int getKor() const { return kor; } }; // to_json függvény a konvertáláshoz void to_json(json& j, const Ember& e) { j = json{{"nev", e.getNev()}, {"kor", e.getKor()}}; } // from_json függvény a visszaalakításhoz void from_json(const json& j, Ember& e) { // Itt mivel privát tagokról van szó, megoldhatjuk úgy, // hogy ideiglenes változókat olvasunk ki, majd e = Ember(név, kor) ha lenne értelme. string n = j.at("nev").get<string>(); int k = j.at("kor").get<int>(); e = Ember(n, k); } int main() { Ember ember("Géza", 45); json j = ember; // to_json segítségével átalakítja // JSON objektum szöveggé alakítása (pretty print 4 space indenttel) és fájlba írás ofstream fajl("ember.json"); fajl << j.dump(4); fajl.close(); // Olvasás fájlból és visszaalakítás Ember objektummá ifstream be("ember.json"); json j2; be >> j2; // beolvassuk a JSON tartalmat Ember ujEmber = j2.get<Ember>(); // from_json segítségével Emberré alakítjuk cout << "Név: " << ujEmber.getNev() << ", Kor: " << ujEmber.getKor() << endl; }</syntaxhighlight> Magyarázat: <ul> <li><p>A <code>to_json</code> és <code>from_json</code> függvényeket a nlohmann/json könyvtár speciális sablonmechanizmus útján automatikusan használja, mikor egy adott típusú objektumot közvetlenül JSON-né konvertálunk vagy vissza. A fenti kódban, amikor <code>json j = ember;</code> sor fut, a fordító megtalálja a megfelelő <code>to_json(json&amp;, const Ember&amp;)</code> függvényt, és azt hívja meg. Hasonlóan a <code>j2.get&lt;Ember&gt;()</code> híváskor a <code>from_json(const json&amp;, Ember&amp;)</code> függvényt hívja, hogy létrehozza az Ember példányt.</p></li> <li><p>A JSON formátum szerint itt az <code>Ember</code> objektum így nézne ki a fájlban (ember.json):</p> <syntaxhighlight lang="json">{ "nev": "Géza", "kor": 45 }</syntaxhighlight> <p>Ez egy egyszerű kulcs-érték struktúra.</p></li> <li><p>A fájlba írás <code>std::ofstream</code>-fal, olvasás <code>std::ifstream</code>-fal történik (fejléc: <code>&lt;fstream&gt;</code>). Egyszerűen úgy használjuk, mint a cout-ot vagy cin-t, csak fájlba irányítva.</p></li> <li><p>Fontos megjegyezni, hogy a fenti <code>from_json</code> megoldás akkor működik, ha az <code>Ember</code> osztálynak van megfelelő konstruktora, vagy default konstruktora és setterei. Máskülönben a közvetlen visszaalakítás trükkösebb lehet. Alternatív megoldás, ha a <code>from_json</code> egy külön publikus statikus függvényt hív, ami például privát tagokkal is boldogulhat, vagy baráttá tesszük.</p></li></ul> '''JSON használata Observer minta kapcsán''': Az Observer mintánál tipikusan arról van szó, hogy ha egy adatmodell változik, értesítjük a megfigyelőket, például hogy frissítsék a kijelzőt vagy mentsék az adatokat. Ekkor hasznos lehet JSON formátumba kimenteni az aktuális állapotot, vagy a változásokat logolni. Összességében a JSON mentés megkönnyíti az adatok más rendszerekkel való cseréjét (mivel a JSON univerzálisan érthető formátum, pl. webes API-k is használják), és ember számára is olvasható. Alternatívaként persze használhatunk más formátumokat is (CSV, XML, vagy saját bináris formátum), de a JSON manapság egy jó választás, ha platformfüggetlen, könnyen debug-olható formátumot szeretnénk. <span id="observer-tervezési-minta"></span> == Observer tervezési minta == Az '''Observer minta''' egy szoftvertervezési minta, amely a '''publikáló-feliratkozó (publish-subscribe)''' elvet követi. A lényege, hogy van egy '''Subject''' (téma, megfigyelt alany) objektum, amely állapotváltozásairól értesíteni szeretne más objektumokat, az '''Observer'''-eket (megfigyelőket). Az Observer-ek feliratkoznak a Subject-nél, és amikor a Subject-ben valami történik (például megváltozik egy adat), akkor a Subject értesíti az összes megfigyelőt valamilyen módon (tipikusan egy meghívott metóduson keresztül). Ez a minta lazán csatolt rendszert eredményez: a Subject nem tud sokat az Observer-ekről, csak azt, hogy van egy közös interfészük, amin keresztül értesíteni lehet őket. Az Observer-ek pedig csak a feliratkozást végzik el, utána “passzívan” várják az értesítéseket. '''Tipikus példa''': Vegyünk egy egyszerű példát: van egy adatforrás objektum (Subject), mondjuk egy hőmérő szenzor adatait tárolja, és több kijelző (Observer) van, ami kiírja a hőmérsékletet különböző formátumban. Amikor a hőmérséklet változik, a szenzor objektum értesíti a kijelző objektumokat, hogy frissítsék magukat. '''Observer minta C++ megvalósítása''': # Definiálunk egy Observer interfészt (absztrakt osztályt), mondjuk <code>IHőmérsékletObserver</code>, aminek van egy <code>ertesites(float ujErtek)</code> tiszta virtuális metódusa. # Definiálunk egy Subject osztályt, pl. <code>Homero</code> (hőmérő), ami tárol egy listát az Observerekről (tipikusan pointereket vagy okos pointereket az interfész típusra) és van benne: #* <code>feliratkozik(IHőmérsékletObserver* obs)</code> – ezzel lehet hozzáadni egy megfigyelőt. #* <code>leiratkozik(IHőmérsékletObserver* obs)</code> – ezzel eltávolítani. #* Valamint amikor változik a hőmérséklet (pl. setTemperature függvény), akkor meghívja a privát <code>ertesitMindenkit()</code> függvényét, ami végigmegy a listán és mindegyik observer <code>ertesites()</code> metódusát meghívja az új értékkel. # A konkrét Observerek (pl. <code>KijelzoLCD</code>, <code>KijelzoGrafikus</code>) megvalósítják az Observer interfészt, tehát saját <code>ertesites</code> függvényük van, amiben mondjuk kiírják a kapott értéket valahová. Egyszerűsített példa kóddal: <syntaxhighlight lang="cpp">#include <vector> #include <algorithm> // Observer interfész class IHőmérsékletObserver { public: virtual void frissit(float homerseklet) = 0; virtual ~IHőmérsékletObserver() {} }; // Subject osztály class Homero { private: float homerseklet; std::vector<IHőmérsékletObserver*> megfigyelok; public: void feliratkozik(IHőmérsékletObserver* obs) { megfigyelok.push_back(obs); } void leiratkozik(IHőmérsékletObserver* obs) { megfigyelok.erase(std::remove(megfigyelok.begin(), megfigyelok.end(), obs), megfigyelok.end()); } void beallitHomerseklet(float ujErtek) { homerseklet = ujErtek; ertesitMegfigyelok(); } private: void ertesitMegfigyelok() { for(IHőmérsékletObserver* obs : megfigyelok) { obs->frissit(homerseklet); } } }; // Két példa observer osztály: class LCDKijelzo : public IHőmérsékletObserver { public: void frissit(float homerseklet) override { std::cout << "[LCD] Új hőmérséklet: " << homerseklet << " C fok" << std::endl; } }; class GrafikusKijelzo : public IHőmérsékletObserver { public: void frissit(float homerseklet) override { std::cout << "[Grafikus] Hőmérséklet grafikon frissítése az új értékkel: " << homerseklet << " C" << std::endl; } };</syntaxhighlight> Használat: <syntaxhighlight lang="cpp">int main() { Homero homero; LCDKijelzo lcd; GrafikusKijelzo grafikus; homero.feliratkozik(&lcd); homero.feliratkozik(&grafikus); homero.beallitHomerseklet(22.5f); homero.beallitHomerseklet(23.0f); homero.leiratkozik(&lcd); homero.beallitHomerseklet(21.0f); }</syntaxhighlight> Lehetséges kimenet: <pre>[LCD] Új hőmérséklet: 22.5 C fok [Grafikus] Hőmérséklet grafikon frissítése az új értékkel: 22.5 C [LCD] Új hőmérséklet: 23 C fok [Grafikus] Hőmérséklet grafikon frissítése az új értékkel: 23 C [Grafikus] Hőmérséklet grafikon frissítése az új értékkel: 21 C</pre> Látható, hogy az Observer minta segítségével rugalmasan hozzáadhatunk vagy eltávolíthatunk megfigyelőket anélkül, hogy a <code>Homero</code> osztályt módosítani kellene. A Homero csak az interfészen keresztül kommunikál (hívja a <code>frissit</code>-et), nem tudja, valójában milyen konkrét osztályok vannak a listában. Ugyanígy a kijelzők sem “kérdezik le” a hőmérőt folyamatosan, hanem a hőmérő tolja ki nekik az új adatot. '''Observer minta a gyakorlatban''': Számos GUI keretrendszer eseménykezelése (pl. kattintás esemény figyelése) vagy akár a standard könyvtár <code>std::condition_variable</code> jelzésmechanizmusa is hasonló elven működik. Az Observer minta segít '''szétválasztani a modellt és a nézetet''' (model-view), illetve implementálni lehet vele az MVC (Model-View-Controller) architektúrában a modell-&gt;view értesítést. '''Megjegyzés:''' Fontos a leiratkozás kezelése (fent egyszerűen kivettük a vektorból az elemet). Bonyolultabb helyzetekben figyelni kell arra is, ha egy Observer életciklusa véget ér (pl. törlődik) akkor leiratkozzon, különben a Subject egy lógó pointert próbálna értesíteni. Erre okos megoldás lehet gyenge pointerek (weak_ptr) használata, vagy az, hogy az Observer értesítéskor vissza is igazolhat, stb., de ez már részletkérdés. <span id="összegzés"></span> == Összegzés == Ez a bevezető áttekintette a C++ nyelv alapvető elemeit és az objektumorientált programozás főbb koncepcióit a nyelvben. Megismertük a '''nyelvi alapokat''' (típusok, konstansok, I/O, névterek, függvények és paraméterátadás, memória kezelés), majd elmélyedtünk az '''OOP alapelvekben''': osztályokat definiáltunk, láttuk az '''egységbezárás''' fontosságát a privát adatokkal és publikus metódusokkal, a '''konstruktorok''' és '''destruktorok''' szerepét az objektumok életciklusában, valamint az '''öröklés''' mechanizmusát, amellyel újrahasznosítható és kiterjeszthető kódot írhatunk. A '''polimorfizmus''' révén a program képes a futás idején az adott objektum típusának megfelelő viselkedést megvalósítani, amit a virtuális függvények és az absztrakt osztályok tettek lehetővé. Szó esett továbbá a '''sablonokról''', amelyekkel típusfüggetlen kódot írhatunk, illetve az '''operátorok túlterheléséről''', mellyel természetesebb szintaxist adhattunk saját típusainknak. Végül kitekintettünk a '''fájlkezelésre''', különösen a JSON formátum használatára az adatok mentésében, és az '''Observer tervezési mintára''', amely összetettebb alkalmazásokban segít az objektumok közti esemény-alapú kommunikáció megszervezésében. A C++ egy erős és sokrétű nyelv, de komplexitása miatt fokozatosan érdemes elsajátítani. A fenti témák megértése szilárd alapot nyújt a kezdő és középhaladó programozóknak, hogy magabiztosan írjanak C++ programokat és kiaknázzák a nyelv nyújtotta lehetőségeket. Fontos a sok gyakorlás: a koncepciók akkor rögzülnek igazán, ha kipróbáljuk őket valódi kódban, kísérletezünk, és akár hibákon keresztül tanulunk. A következő lépésként javasolt mélyebben foglalkozni a modern C++ további funkcióival (okos mutatók, lambda kifejezések, mozgástechnika stb.), valamint további tervezési mintákkal és a szabványos könyvtár eszközeivel. =C++ Programozás tanterv= Ez az egyéves, BSc szintű tanterv a C++ programozás elsajátítását tűzi ki célul. Különös hangsúlyt fektet a versenyprogramozásra és a szoftverfejlesztői gyakorlatban is hasznosítható tudásra. A tananyag lépcsőzetesen, több mint 100 lépésben épül fel az alapoktól a középhaladó szintig és azon túl. A hallgatók megismerkednek a C++ nyelv alapvető szintaxisával és programozási koncepcióival, majd fokozatosan továbblépnek a haladóbb C++ technikákra (például az STL használata, memóriaoptimalizálás, többszálú programozás). Emellett elmélyülnek az algoritmusok és adatstruktúrák világában (dinamikus programozás, gráfalgoritmusok, keresési és rendezési algoritmusok stb.). A tanterv kitér a versenyprogramozási stratégiákra és problémamegoldási módszerekre is, minden szakaszban gyakorlati példákkal és feladatokkal segítve a tanultak alkalmazását. A tanulási folyamat projekt alapú megközelítést is alkalmaz: a hallgatók kisebb-nagyobb programozási projekteken keresztül fejlesztik képességeiket és tanulnak a kódoptimalizálási szempontokról is. Az alábbiakban a tanterv egy éves ütemezését heti bontásban mutatjuk be, hogy a hallgatók egyenletes ütemben, szervezetten haladhassanak. <span id="hónap-c-programozás-alapjai"></span> == 1. hónap: C++ programozás alapjai == Az első hónap célja, hogy a hallgatók stabil alapokat szerezzenek a C++ nyelvben. Ezen hetek alatt megismerik a fejlesztői környezet beállítását, a programok fordításának és futtatásának menetét, valamint a nyelv alapvető elemeit: a változókat, adattípusokat, bemenetet-kimenetet és operátorokat. Sorra kerülnek az egyszerű vezérlési szerkezetek (feltételes elágazások és ciklusok), amelyekkel már kisebb, de működőképes programokat írhatnak. <span id="hét-fejlesztői-környezet-és-első-program"></span> === 1. hét: Fejlesztői környezet és első program === * Fejlesztőkörnyezet (IDE) és C++ fordító telepítése, beállítása<br /> * Egyszerű '''Hello, World!''' program megírása, fordítása és futtatása<br /> * A C++ program alapvető szerkezete: <code>#include</code> direktívák, <code>main()</code> függvény, kimenet a konzolra <span id="hét-változók-és-adattípusok-io-műveletek"></span> === 2. hét: Változók és adattípusok, I/O műveletek === * Alapvető adattípusok (egész, lebegőpontos, karakter, logikai) és változók deklarálása, inicializálása<br /> * Konzolos bemenet és kimenet használata: <code>std::cout</code> és <code>std::cin</code> alapok<br /> * Alapvető műveletek változókkal: értékadás, aritmetikai műveletek, műveleti sorrend és zárójelezés <span id="hét-feltételes-elágazások-ifswitch-és-logikai-műveletek"></span> === 3. hét: Feltételes elágazások (if/switch) és logikai műveletek === * Feltételes utasítások: <code>if-else</code> szerkezet használata egyszerű programokban<br /> * Összehasonlító és logikai operátorok (<code>==, !=, &lt;, &gt;, &amp;&amp;, ||, !</code>) használata összetettebb feltételekben<br /> * Többágú elágazás: <code>switch</code> szerkezet bemutatása és példák (pl. egyszerű menü rendszer)<br /> * Példafeladatok: páros vagy páratlan szám eldöntése, értéktartomány ellenőrzése, érdemjegyhez szöveges minősítés rendelése <span id="hét-ciklusok-for-while-és-egyszerű-algoritmusok"></span> === 4. hét: Ciklusok (for, while) és egyszerű algoritmusok === * Ismétlődő műveletek megvalósítása <code>while</code>, <code>do-while</code> és <code>for</code> ciklusokkal<br /> * A ciklusvezérlés eszközei: <code>break</code> és <code>continue</code> kulcsszavak használata<br /> * Egyszerű algoritmusok ciklusokkal: összegzés, szorzat számítása, faktoriális, Fibonacci-számok generálása<br /> * Gyakorló feladatok: adott szám faktoriálisának kiszámítása, első N szám összegének meghatározása, számsorozatok és egyszerű minták kiíratása <span id="hónap-programozási-alapismeretek-elmélyítése"></span> == 2. hónap: Programozási alapismeretek elmélyítése == A második hónapban a hallgatók tovább bővítik alapismereteiket és elkezdik összetettebb programstruktúrák alkalmazását. Terítékre kerülnek a függvények mint a kód strukturálásának eszközei, valamint a tömbök használata az adatok tárolására és kezelésére. Emellett megismerkednek az algoritmikus gondolkodás alapjaival, például a rekurzió fogalmával, amely fontos szerepet játszik számos algoritmusban. <span id="hét-függvények-és-modularitás-alapjai"></span> === 5. hét: Függvények és modularitás alapjai === * Saját függvények írása és hívása: függvényfej definíciója, paraméterátadás és visszatérési értékek<br /> * A program strukturálása függvényekkel a jobb áttekinthetőség érdekében (például matematikai műveletek külön függvénybe szervezése)<br /> * Lokális és globális változók hatóköre, változók élettartama és a névütközés fogalma <span id="hét-haladó-függvénykezelés-és-rekurzió"></span> === 6. hét: Haladó függvénykezelés és rekurzió === * Érték szerinti és referencia szerinti paraméterátadás megkülönböztetése (<code>pass by value</code> vs. <code>pass by reference</code>)<br /> * Függvény-túlterhelés (function overloading) alapelve: több függvény definiálása azonos névvel, de különböző paraméterlistával<br /> * A rekurzió fogalma: önmagukat hívó függvények és a verem (stack) szerepe a rekurzív folyamatban<br /> * Egyszerű rekurzív példák: faktoriális és Fibonacci számítás rekurzívan, rekurzió vs. iteráció összehasonlítása <span id="hét-tömbök-használata-és-algoritmikus-gyakorlat"></span> === 7. hét: Tömbök használata és algoritmikus gyakorlat === * Egydimenziós tömbök deklarálása és használata, elemek elérése index segítségével<br /> * Tömbök bejárása ciklusokkal (pl. tömb elemeinek összege, minimum/maximum keresése)<br /> * Többdimenziós tömbök alapjai (mátrixok) és egyszerű műveletek velük (pl. mátrix inicializálása és kiíratása)<br /> * Gyakorló feladatok: tömb elemeinek átlagának kiszámítása, adott érték keresése a tömbben, mátrix transzponálása <span id="hét-mutatók-pointerek-és-a-memória-kezelése-alapfokon"></span> === 8. hét: Mutatók (pointerek) és a memória kezelése alapfokon === * A mutató fogalma: memória címek kezelése, pointer változók deklarálása és inicializálása<br /> * Pointer műveletek: érték elérése pointeren keresztül (dereferálás, <code>*</code> operátor) és cím lekérdezése (<code>&amp;</code> operátor)<br /> * Mutatók használata tömbökkel: tömbnevek mint pointerek, pointer aritmetika alapjai (előre léptetés a memóriában)<br /> * Gyakori pointer hibák (null pointer, vad pointer) fogalma és elkerülésük módszerei <span id="hónap-memóriakezelés-és-összetettebb-adatszerkezetek"></span> == 3. hónap: Memóriakezelés és összetettebb adatszerkezetek == A harmadik hónap a memória kezelésének mélyebb megértésére és további adatkezelési eszközök elsajátítására koncentrál. A hallgatók megtanulják a dinamikus memóriafoglalás módját és azt, hogyan bánjanak felelősen a foglalt memóriával (felszabadítás, memóriahibák elkerülése). E hetek során terítékre kerül a hivatkozás (<code>reference</code>) fogalma, a C++ <code>string</code> osztály használata a karakterláncok kényelmes kezeléséhez, valamint egyszerű adatszerkezetek, például a struktúrák definiálása és alkalmazása. <span id="hét-dinamikus-memóriafoglalás"></span> === 9. hét: Dinamikus memóriafoglalás === * Memóriamodellek áttekintése: '''stack''' (verem) vs '''heap''' (kupac) és szerepük a program futása során<br /> * Dinamikus memória foglalása és felszabadítása C++-ban: <code>new</code> és <code>delete</code> (tömbök esetén <code>new[]</code> és <code>delete[]</code>) használata<br /> * Példa: dinamikusan méretezhető tömb létrehozása futási időben (pl. a felhasználó által megadott méret alapján)<br /> * Memóriaszivárgás (memory leak) fogalma és elkerülése a foglalt memória felszabadításával a megfelelő helyen <span id="hét-referenciák-és-mutatók-haladó-használata"></span> === 10. hét: Referenciák és mutatók haladó használata === * Referenciák (<code>&amp;</code>) fogalma és különbsége a pointerhez képest; a referencia mint állandó alias egy változóra<br /> * Referencia szerinti paraméterátadás függvényeknek (hatékonyság: másolás elkerülése nagyobb objektumok esetén)<br /> * Konstans referenciák használata (pl. csak olvasható paraméter átadásához)<br /> * Példa: értékek cseréje egy függvényben pointerekkel vs. referenciákkal (különböző megoldások összehasonlítása, pl. <code>swap</code> megvalósítása) <span id="hét-sztringek-kezelése-stdstring"></span> === 11. hét: Sztringek kezelése (<code>std::string</code>) === * A <code>std::string</code> osztály használata a C stílusú karaktertömbök helyett (alap műveletek: összefűzés, hossz lekérdezése, karakter elérése indexszel)<br /> * Gyakoribb string műveletek: összehasonlítás, részstring kivágása (<code>substr</code>), keresés egy stringben (<code>find</code>)<br /> * Teljes sor beolvasása a bemenetről <code>std::getline</code> segítségével (buffer overflow problémák elkerülése a <code>gets</code>-szel szemben)<br /> * Példák: két string összefűzése és összehasonlítása, szóösszeszámolás (hány szó van egy beolvasott mondatban) <span id="hét-struktúrák-és-felhasználói-típusok"></span> === 12. hét: Struktúrák és felhasználói típusok === * Strukturált adatok tárolása <code>struct</code> segítségével: saját adattípus létrehozása több adat (mező) csoportosítására<br /> * Struktúra definiálása és használata példával (pl. <code>Diak</code> struktúra: név, életkor, átlag)<br /> * Struktúratömbök létrehozása és feldolgozása (pl. több diák adatainak kezelése egy tömbben, keresés adott nevű diákra)<br /> * Kitekintés: a <code>struct</code> és <code>class</code> közti formai különbség C++-ban (alapértelmezett hozzáférési szint: <code>struct</code>-nál public, <code>class</code>-nál private) <span id="hónap-algoritmusok-alapjai-és-egyszerű-adatstruktúrák"></span> == 4. hónap: Algoritmusok alapjai és egyszerű adatstruktúrák == A negyedik hónap az algoritmikus gondolkodás megalapozásával foglalkozik. A hallgatók megtanulják, hogyan értékeljék egy algoritmus hatékonyságát (számítási komplexitás), és megismerik az adatok rendezésének és keresésének alapvető módszereit. Emellett sor kerül néhány egyszerűbb adatstruktúra (például verem és sor) működési elvének és felhasználásának bemutatására is. Ezek az ismeretek létfontosságúak a hatékony programok írásához és a versenyprogramozási feladatok megoldásához. <span id="hét-algoritmikus-komplexitás-és-hatékonyság"></span> === 13. hét: Algoritmikus komplexitás és hatékonyság === * Algoritmusok időbeli és memória komplexitásának fogalma (Big O notáció alapjai)<br /> * Példák különböző időkomplexitású kódokra: lineáris (<code>O(n)</code>), négyzetes (<code>O(n^2)</code>), logaritmikus (<code>O(log n)</code>), kombinált (<code>O(n log n)</code>)<br /> * Egyszerű teljesítményelemzés: a bemeneti méret növekedésének hatása a futási időre (kis vs nagy inputesetek összehasonlítása)<br /> * Gyakorlati megfigyelés: különböző megoldások futási idejének mérése (pl. ciklussal összegzés vs. matematikai képlettel számítás) <span id="hét-rendezési-algoritmusok-alapjai"></span> === 14. hét: Rendezési algoritmusok alapjai === * Az adatrendezés szükségessége és gyakori alkalmazásai (pl. adatok előkészítése kereséshez)<br /> * Egyszerű rendezési algoritmusok megismerése és implementálása: buborékrendezés, kiválasztásos rendezés<br /> * Az algoritmusok összehasonlítása hatékonyság szempontjából (műveletszám becslése kis adatméreten)<br /> * Beépített rendezés használata: <code>std::sort</code> bemutatása kis példával, és utalás a mögöttes algoritmusokra (quicksort, mergesort) <span id="hét-keresési-algoritmusok"></span> === 15. hét: Keresési algoritmusok === * Lineáris keresés egy sorozatban és annak időkomplexitása (<code>O(n)</code>)<br /> * Hatékonyabb keresés rendezett adatokban: bináris keresés algoritmusa (<code>O(log n)</code>) és implementációja (rekurzív és iteratív változat)<br /> * A bináris keresés alkalmazási feltétele: rendezett bemenet szükségessége a helyes működéshez<br /> * Példafeladat: egy adott érték keresése rendezett tömbben lineáris vs bináris kereséssel, az eredmények és futási idők összehasonlítása <span id="hét-adatstruktúrák-verem-és-sor"></span> === 16. hét: Adatstruktúrák – verem és sor === * Absztrakt adatstruktúrák: verem (stack – LIFO) és sor (queue – FIFO) működési elve, felhasználási területei<br /> * Verem implementálása tömb segítségével vagy <code>std::stack</code> konténeradapter használata<br /> * Sor implementálása vagy <code>std::queue</code> használata (alapértelmezett megvalósítás: deque)<br /> * Példafeladat: zárójelek helyességének ellenőrzése veremmel (illeszkedő zárójel-párok keresése egy kifejezésben), ügyfélkiszolgálás modellezése sor adatszerkezettel <span id="hónap-objektumorientált-programozás-oop-alapjai"></span> == 5. hónap: Objektumorientált programozás (OOP) alapjai == Az ötödik hónapban a tananyag az objektumorientált programozás (OOP) elveire vált, amelyek a modern C++ fejlesztés alapját képezik. A hallgatók megtanulják, miként hozhatnak létre saját osztályokat és objektumokat, és hogyan alkalmazhatják az OOP főbb fogalmait (például az öröklődést és a polimorfizmust) a kód újrafelhasználhatóságának és karbantarthatóságának javítására. Ezek az ismeretek nem csak a versenyprogramozásban, hanem a nagyobb szoftverprojektekben is kulcsfontosságúak. <span id="hét-osztályok-és-objektumok"></span> === 17. hét: Osztályok és objektumok === * Saját osztály definíciója C++-ban: adattagok (mezők) és függvénytagok (metódusok) deklarálása<br /> * Objektum példányosítása és használata: például egy <code>Pont</code> osztály létrehozása (x, y koordinátákkal) és metódus a távolság számítására<br /> * Adatelrejtés és hozzáférés-módosítók: <code>public</code>, <code>private</code> (és <code>protected</code>) kulcsszavak szerepe az osztályokban<br /> * Egyszerű példa: egy '''Számláló''' osztály, amely növeli vagy csökkenti egy belső számlálót és lekérdezhető az aktuális értéke <span id="hét-konstruktorok-destruktorok-és-az-osztályok-részletei"></span> === 18. hét: Konstruktorok, destruktorok és az osztályok részletei === * Konstruktorok szerepe és definíciója: alapértelmezett és paraméterezett konstruktor; konstruktor túlterhelése többféle inicializáláshoz<br /> * Destruktor jelentősége a dinamikus memória felszabadításánál (ha az osztály dinamikus erőforrást használ, a destruktorban való felszabadítás)<br /> * A <code>this</code> mutató fogalma és használata (pl. folytonos metódushívás esetén vagy amikor egy objektum önmagára mutató pointere szükséges)<br /> * Példa: '''Komplex''' szám osztály konstruktorral (két <code>double</code> adattaggal) és hozzá destruktor (bár itt konkrét erőforrás nincs, a példa kedvéért megvalósítva) <span id="hét-öröklés-inheritance-és-származtatott-osztályok"></span> === 19. hét: Öröklés (inheritance) és származtatott osztályok === * Öröklés fogalma: egy bázisosztály tulajdonságainak és metódusainak átvétele egy származtatott osztályban<br /> * Öröklési láthatóság (<code>public</code>, <code>protected</code>, <code>private</code> öröklés) és hatása a tagok elérhetőségére a leszármazottban<br /> * Példa: <code>Allat</code> bázisosztály, és belőle származtatott <code>Kutya</code> és <code>Macska</code> osztályok, amelyek további tulajdonságokat vagy metódusokat adnak hozzá (ugatás, nyávogás metódus stb.)<br /> * Az '''is-a''' kapcsolat megértése és helyes használata (mikor érdemes öröklést alkalmazni és mikor nem) <span id="hét-polimorfizmus-és-virtuális-függvények"></span> === 20. hét: Polimorfizmus és virtuális függvények === * Polimorfizmus fogalma: ugyanazon típusú pointer/reference alatt futásidőben többféle konkrét osztály viselkedhet eltérően (virtuális függvények révén)<br /> * Virtuális függvények deklarálása a bázisosztályban és felüldefiniálása (<code>override</code>) a leszármazott osztályokban<br /> * Absztrakt osztályok és tisztán virtuális függvények: ha egy osztályt nem példányosítunk közvetlenül, csak keretet ad a leszármazottaknak (interface jelleg)<br /> * Példa: Geometriai alakzatok osztályhierarchiája – egy <code>Alakzat</code> absztrakt osztály virtuális <code>terulet()</code> függvénnyel, melyet a <code>Teglalap</code> és <code>Kor</code> osztályok saját képlettel valósítanak meg <span id="hónap-haladó-c-technikák-és-stl-bevezetése"></span> == 6. hónap: Haladó C++ technikák és STL bevezetése == A hatodik hónapban a hallgatók megismerkednek a C++ nyelv néhány haladóbb lehetőségével (például az operátorok túlterhelésével és a sablonok használatával), és elkezdik felfedezni a Standard Template Library (STL) alapjait. Az operátor túlterhelés (operator overloading) segítségével a saját osztályok viselkedését a beépített operátorokhoz hasonlóvá tehetik, míg a sablonok (template-ek) használata lehetővé teszi általános érvényű kód írását. A kivételkezelési mechanizmus megismerése segít a robusztusabb programok készítésében. Ebben a szakaszban megkezdjük az STL főbb komponenseinek (konténerek és algoritmusok) tárgyalását is, melyek hatékony eszközöket nyújtanak a gyakori programozási feladatokhoz. <span id="hét-operátor-túlterhelés-és-egyéb-nyelvi-finomságok"></span> === 21. hét: Operátor túlterhelés és egyéb nyelvi finomságok === * Az operátor-túlterhelés fogalma és egyszerű esetei: pl. a <code>+</code> operátor túlterhelése egy '''Komplex''' szám osztályban, hogy két komplex objektumot össze lehessen adni<br /> * Felhasználói típusok integrálása a nyelvbe operátorokkal: összehasonlító operátorok (<code>==, &lt;</code>) definiálása saját osztályokhoz a rendezés vagy keresés támogatására<br /> * Barát függvények (<code>friend</code>) szerepe operátorok túlterhelésénél (pl. &lt;&lt; operátor túlterhelése ostream-hez, hogy az objektum kiírható legyen)<br /> * Figyelmeztetés: az operátorok túlterhelését ésszerűen használjuk – a kód olvashatóságának megőrzése fontos szempont <span id="hét-sablonok-templates-alapjai"></span> === 22. hét: Sablonok (Templates) alapjai === * Függvény sablonok: általános függvények írása, amelyek különböző típusú paraméterekkel is működnek (példa: típusfüggetlen minimumot kereső függvény sablonja)<br /> * Osztály sablonok: saját általános osztály készítése sablonként (egyszerű példa: <code>Par</code> sablon két tetszőleges típusú érték párban történő tárolására)<br /> * A sablonok jelentősége: kód újrafelhasználása típusfüggetlen módon, és az STL konténerek megértésének alapja (mivel az STL implementációk sablon osztályok)<br /> * Gyakorlati példa: generikus <code>swap</code> függvény sablon létrehozása, mely bármilyen típusú két értéket meg tud cserélni <span id="hét-kivételkezelés-exception-handling"></span> === 23. hét: Kivételkezelés (Exception handling) === * A kivételek szerepe a hibakezelésben: különbség a hagyományos hibakód-visszaadáshoz képest (a vezérlés átugorhat több hívási szintet is hiba esetén)<br /> * <code>try-catch</code> blokkok használata, több <code>catch</code> ág különböző kivétel típusokra (standard kivételek: pl. <code>std::exception</code>, <code>std::out_of_range</code> stb.)<br /> * Saját kivétel definíciója szükség esetén (egyedi osztály, ami öröklődik std::exception-ből) és kivétel dobása (<code>throw</code>)<br /> * Példa: hiba kezelése osztással nullával – dobjunk <code>std::runtime_error</code> kivételt a függvényben, és kezeljük a hívó kódban a hibát egy megfelelő üzenet kiírásával <span id="hét-a-standard-template-library-stl-áttekintése-vektorok"></span> === 24. hét: A Standard Template Library (STL) áttekintése (vektorok) === * Az STL fogalma és részei: konténerek, iterátorok, algoritmusok, függvényobjektumok rövid áttekintése<br /> * A '''vector''' (<code>std::vector</code>) konténer részletes megismerése: dinamikus tömbként való használat, elemek hozzáadása (<code>push_back</code>), elérése indexxel, méretének lekérdezése (<code>size</code>)<br /> * Összehasonlítás: statikus tömb vs <code>std::vector</code> (előnyök: rugalmasság futásidőben, biztonságos memóriahozzáférés at() használatával, méretezhetőség)<br /> * Egyszerű példa: egész számok listájának tárolása és rendezése <code>std::vector</code> segítségével (beolvasott adatok rendezése <code>std::sort</code> használatával) <span id="hónap-stl-konténerek-és-algoritmusok-mélyítése"></span> == 7. hónap: STL konténerek és algoritmusok mélyítése == A hetedik hónapban a hallgatók elmélyednek az STL konténerek és algoritmusok használatában, valamint megismerkednek a modern C++ egy-két további vívmányával. Tovább tárgyaljuk a különböző konténertípusokat (lista, halmaz, asszociatív tömb stb.), valamint az ezekhez tartozó algoritmusokat és függvényeket. Emellett szó lesz a lambda kifejezések használatáról az STL-lel együtt, és az okos pointerekről, amelyek a biztonságos memóriakezelést segítik elő a fejlesztői gyakorlatban. <span id="hét-gyakori-stl-konténerek-i.-lista-verem-sor"></span> === 25. hét: Gyakori STL konténerek I. (lista, verem, sor) === * A '''lista''' (<code>std::list</code>, dupla láncolt lista) konténer használata és jellemzői, összehasonlítva a vektorral (hol előnyös: pl. lista közepébe beszúrás/törlés hatékonyabb)<br /> * Verem és sor konténer-adapterek: <code>std::stack</code> és <code>std::queue</code> használata (belsőleg ezek alapértelmezetten <code>deque</code>-ot vagy listát használnak a tároláshoz)<br /> * A '''deque''' (<code>std::deque</code>, kettős végű sor) bemutatása röviden mint a stack/queue alapértelmezett tárolója (elejéről és végéről is hatékony műveletek)<br /> * Példák: verem használata visszafelé történő bejáráshoz, sor használata egy egyszerű ügyfélsor modellezéséhez <span id="hét-gyakori-stl-konténerek-ii.-halmaz-és-asszociatív-tömbök"></span> === 26. hét: Gyakori STL konténerek II. (halmaz és asszociatív tömbök) === * '''Halmaz''' (<code>std::set</code>) és multiset (többszörös előfordulást engedő halmaz) használata, tipikus műveletek (beszúrás, törlés, keresés) és ezek időkomplexitása (<code>O(log n)</code>)<br /> * '''Térkép''' (<code>std::map</code>, kulcs-érték párok rendezett tárolója) és '''hash tábla''' (<code>std::unordered_map</code>) bemutatása, használata<br /> * Hash alapú konténerek (<code>unordered_set</code>, <code>unordered_map</code>) összehasonlítása a rendezett változatokkal (átlagos esetben <code>O(1)</code> műveletek vs garantált <code>O(log n)</code>)<br /> * Példafeladat: szógyakoriság számlálása egy szövegben <code>std::map</code> vagy <code>std::unordered_map</code> segítségével (kulcs: szó, érték: előfordulások száma) <span id="hét-stl-algoritmusok-és-lambda-kifejezések"></span> === 27. hét: STL algoritmusok és lambda kifejezések === * Az <code>&lt;algorithm&gt;</code> könyvtár gyakran használt algoritmusai: pl. <code>std::sort</code>, <code>std::reverse</code>, <code>std::lower_bound</code>, <code>std::unique</code>, <code>std::find</code> – használatuk konkrét példákkal<br /> * Iterátorok használata az algoritmusokkal: begin/end iterátorok lekérése, konstans iterátorok, valamint a C++11 '''range-based for''' ciklus konténerek bejárására<br /> * '''Lambda kifejezések''' (C++11) bemutatása: névtelen függvények írása helyben, például egyedi rendezési kritérium megadására a <code>std::sort</code>-nál<br /> * Példa: összetett objektumok (pl. diák struktúrák) rendezése többféle szempont szerint lambda kifejezéssel (jegy vagy név szerinti rendezés) <span id="hét-okos-pointerek-és-erőforrás-kezelés"></span> === 28. hét: Okos pointerek és erőforrás-kezelés === * '''Okos pointerek''' szerepe: automatikus memóriafelszabadítás RAII elv alapján. <code>std::unique_ptr</code> (egyedi tulajdonlás) és <code>std::shared_ptr</code> (megosztott tulajdonlás) működése, alapvető használata<br /> * Mikor melyik okos pointert használjuk: egyedüli tulajdonlás vs megosztott (példák: egy objektum több helyen is szükséges, megosztott pointer használata; vagy egyszerű lokális erőforrás, unique_ptr használata)<br /> * Gyakorlati példa: dinamikusan foglalt objektum kezelése okos pointerrel manuális <code>new</code>/<code>delete</code> helyett (pl. dinamikus tömb átcsomagolása <code>std::unique_ptr</code>-be)<br /> * Egyéb RAII példák: fájl megnyitása és automatikus zárása egy objektum destruktorában (erőforrások biztos felszabadítása kódlezáráskor) <span id="hónap-többszálú-programozás-és-alacsony-szintű-optimalizációk"></span> == 8. hónap: Többszálú programozás és alacsony szintű optimalizációk == A nyolcadik hónap során a hallgatók betekintést nyernek a párhuzamos programozásba és néhány alacsony szintű optimalizációs technikába. Megismerik a többszálú programok alapjait C++ környezetben, beleértve a szálak létrehozását és a szinkronizáció egyszerű módszereit. Ezt követően olyan nyelvi eszközökkel és programozási technikákkal foglalkozunk, amelyekkel a program teljesítménye tovább javítható, például a bitműveletek és a bitmezők használatával történő memóriaoptimalizálás. <span id="hét-többszálú-programozás-alapjai-multithreading"></span> === 29. hét: Többszálú programozás alapjai (multithreading) === * Új szál indítása C++11 <code>std::thread</code> használatával; példa: párhuzamos feladat futtatása két szálon egyszerre<br /> * A párhuzamos végrehajtás előnyei (gyorsítás többmagos rendszeren) és buktatói (versenyhelyzetek – data race – kialakulása)<br /> * Adatverseny (race condition) fogalma és megelőzésének alapjai<br /> * Egyszerű szinkronizáció <code>std::mutex</code> és <code>std::lock_guard</code> használatával egy kritikus szekció védelmére <span id="hét-többszálúság-szinkronizáció-és-kommunikáció"></span> === 30. hét: Többszálúság – szinkronizáció és kommunikáció === * További szinkronizációs eszközök: feltételi változók (<code>std::condition_variable</code>) használata (példa: termelő-fogyasztó probléma megoldásának felvázolása)<br /> * Szálak közti kommunikáció megvalósítása: például egyik szál számokat generál egy listába, a másik szál folyamatosan figyeli és feldolgozza az új elemeket (wait-notify mechanizmus)<br /> * A többszálú programok tervezési szempontjai: hol érdemes párhuzamosítani, és hol nem (túl sok szál kezelése okozta overhead, kontextusváltások költsége)<br /> * Hibakeresés többszálú környezetben: tipikus problémák felismerése (deadlock, livelock) és elkerülése, debug technikák párhuzamos kódban <span id="hét-bitműveletek-és-bitoptimalizációk"></span> === 31. hét: Bitműveletek és bitoptimalizációk === * Bitműveleti operátorok (<code>&amp;, |, ^, ~, &lt;&lt;, &gt;&gt;</code>) használata és tipikus felhasználásai (bitösszehasonlítás, bitmanipuláció trükkök)<br /> * Bitmaszkok alkalmazása: adott bitek kiolvasása, beállítása, törlése konkrét példákon keresztül<br /> * Hatékony tárolás bit szinten: <code>std::bitset</code> konténer használata nagyszámú logikai érték (bit) tárolására, pl. bitmezők (flags) kezelése<br /> * Gyakorlati példa: bitműveletekkel megoldott feladat – két szám cseréje extra változó nélkül XOR műveletekkel, illetve halmazműveletek (metszet, unió) bitmaskok segítségével <span id="hét-memória--és-teljesítményoptimalizálás"></span> === 32. hét: Memória- és teljesítményoptimalizálás === * A programok teljesítményét és memóriahasználatát befolyásoló tényezők áttekintése<br /> * Ésszerű optimalizálási technikák: pl. memóriafoglalások számának csökkentése, cache-tudatosság (adatok egymás melletti tárolása a jobb kihasználtságért)<br /> * Inline függvények szerepe a teljesítményben, valamint a túlzott optimalizáció veszélyei (a '''premature optimization''' problémája)<br /> * Gyakorlati tippek: fordító optimalizációs kapcsolók (pl. <code>-O2</code>, <code>-O3</code> flag-ek) és profilozó eszközök említése a teljesítmény mérésére és szűk keresztmetszetek megtalálására <span id="hónap-haladó-algoritmusok-és-adatstruktúrák-gráfok"></span> == 9. hónap: Haladó algoritmusok és adatstruktúrák (Gráfok) == A kilencedik hónap visszatér az algoritmusok és adatstruktúrák témaköréhez, immár haladó szinten. A hallgatók megtanulják a gráfok ábrázolásának és bejárásának módjait, valamint néhány alapvető gráfalgoritmust (pl. legrövidebb út keresése, minimális feszítőfa készítése). Emellett a fákat mint speciális adatstruktúrákat is megismerik, amelyek számos probléma hatékony megoldásához szükségesek. Ezek a témák különösen fontosak a versenyprogramozási feladatok magasabb szintjén, és megalapozzák a komplex problémák kezelését. <span id="hét-gráfok-ábrázolása-és-bejárása"></span> === 33. hét: Gráfok ábrázolása és bejárása === * A '''gráf''' fogalma (csúcsok és élek halmaza) és gyakori ábrázolási módjai: szomszédsági mátrix vs. szomszédsági lista<br /> * Mélységi (DFS) és szélességi (BFS) gráfbejárás algoritmusok ismertetése és implementációja<br /> * BFS és DFS alkalmazási területei: pl. összefüggő komponensek számlálása, útkeresés egy labirintusban (rácsgráfban)<br /> * Gyakorlati feladat: adott gráf komponenseinek megállapítása (hány különálló részgráf), vagy legrövidebb út megtalálása egy adott start ponttól BFS segítségével egy nem súlyozott gráfban <span id="hét-útvonal-keresési-algoritmusok-legrövidebb-út"></span> === 34. hét: Útvonal-keresési algoritmusok (legrövidebb út) === * Súlyozott gráf fogalma (élhez tartozó súlyok/távolságok) és a legrövidebb út problémája<br /> * '''Dijkstra algoritmusa''' a legrövidebb út megtalálására egy forrásból – prioritásos sor (<code>std::priority_queue</code>) használata a megvalósításban<br /> * Egyéb legrövidebb út algoritmusok említése: Bellman–Ford (negatív élhosszak esetére), Floyd–Warshall (minden páros legrövidebb utak mátrixa)<br /> * Példafeladat: városok és utak gráfján a legrövidebb út és távolság kiszámítása két megadott város között Dijkstra algoritmussal <span id="hét-fa-adatszerkezetek-és-alkalmazásuk"></span> === 35. hét: Fa adatszerkezetek és alkalmazásuk === * A '''fa''' mint speciális gráf: nincs benne kör, N csúcs esetén N-1 él; példák: családfa, fájlrendszer<br /> * Bináris fa és bináris keresőfa (BST) alapelvei és műveletei (beszúrás, keresés, törlés) – magas szintű áttekintés vagy egyszerű implementáció<br /> * Kiegyensúlyozott fák említése (AVL, piros-fekete fa) és megjegyzés, hogy az <code>std::map</code>/<code>set</code> belső implementációja egy kiegyensúlyozott fa<br /> * Fa bejárási módszerek: preorder, inorder, postorder; alkalmazásuk (pl. kifejezésfák kiértékelése inorder bejárással)<br /> * Példa: egyszerű telefonkönyv megvalósítása bináris keresőfával, ahol a kulcs a név, az adat a telefonszám (keresés név alapján) <span id="hét-minimális-feszítőfa-és-unió-talál-adatszerkezet-union-find"></span> === 36. hét: Minimális feszítőfa és unió-talál adatszerkezet (Union-Find) === * '''Minimális feszítőfa''' (Minimum Spanning Tree – MST) problémája és jelentősége (pl. legrövidebb hálózat kiépítése adott pontok összekötésére)<br /> * Kruskal algoritmusa MST feladatára: élek növekvő súly szerinti rendezése és felvétele, Union-Find adatszerkezet használata a ciklusok elkerülésére<br /> * Union-Find (Disjoint Set Union) adatszerkezet működése: unió és find műveletek, útösszevonás (path compression) és rang alapján egyesítés a hatékonyságért<br /> * Prim algoritmus rövid ismertetése és összehasonlítása Kruskallal (más megközelítés: csúcsok hozzáadása, prioritásos sor használatával)<br /> * Példafeladat: hálózattervezési probléma (pl. minimális összköltségű úthálózat) megoldása Kruskal algoritmussal és Union-Find struktúrával <span id="hónap-dinamikus-programozás-és-visszalépéses-keresés"></span> == 10. hónap: Dinamikus programozás és visszalépéses keresés == A tizedik hónap középpontjában a dinamikus programozási technikák és a visszalépéses keresés (backtracking) állnak. Ezek a módszerek számos összetett probléma megoldását teszik lehetővé, és gyakran szerepelnek versenyprogramozási feladatokban. A hallgatók megismerkednek a dinamikus programozás alapötletével és klasszikus példáival, majd a visszalépéses kereséssel mint az összes lehetőség bejárásának módszerével. Kiemelten foglalkozunk azzal is, hogyan lehet ezeket a módszereket hatékonyabbá tenni optimalizációkkal. <span id="hét-dinamikus-programozás-alapjai"></span> === 37. hét: Dinamikus programozás alapjai === * A dinamikus programozás koncepciója: probléma felbontása kisebb alproblémákra, részmegoldások eltárolása a későbbi felhasználásra (memoizáció vagy táblázatos kitöltés)<br /> * Egyszerű példa: Fibonacci-számok számítása dinamikus programozással (összehasonlítva a tisztán rekurzív megoldással, időbeli nyereség bemutatása)<br /> * Tipikus DP felépítés: állapottér definiálása, átmeneti függvény meghatározása, optimális megoldás rekonstrukciójának lehetősége<br /> * Tárhely-idő kompromisszum: memóriahasználat növelésével (táblázat fenntartása) csökkenthető a futási idő, és fordítva <span id="hét-klasszikus-dinamikus-programozási-feladatok"></span> === 38. hét: Klasszikus dinamikus programozási feladatok === * Leghosszabb közös részszekvencia (Longest Common Subsequence – LCS) problémája és dinamikus programozásos megoldása<br /> * 0-1 hátizsák probléma (Knapsack) megfogalmazása és megoldása DP-vel (táblázat kitöltés soronként vagy oszloponként)<br /> * További alapvető DP példák: lépcsőmászás problémája (hányféleképpen lehet feljutni n lépcsőn 1 vagy 2 lépésekkel), minimális érmefelhasználás adott összeg kifizetésére<br /> * Gyakorló feladat: kisebb DP problémák kódolása és megoldása, a DP tábla kitöltésének vizualizálása a megértés érdekében <span id="hét-haladó-dp-technikák-és-optimalizációk"></span> === 39. hét: Haladó DP technikák és optimalizációk === * Egy- és többdimenziós DP összehasonlítása: állapottér méretének csökkentése (pl. két soros táblázattal való megoldás memóriamegtakarítás céljából)<br /> * Megoldás visszafejtése a DP táblából: pl. LCS megoldás rekonstruálása (a közös szekvencia előállítása a táblázatból), döntések nyomon követése<br /> * Bitmask DP fogalma: dinamikus programozás bitmaszkkal reprezentált állapotokkal (pl. Utazó ügynök probléma (TSP) megemlítése mint példa)<br /> * Gyakorlati példa: kis méretű TSP megoldása bitmask DP-vel, vagy más kombinatorikus optimalizációs feladat állapotainak bites reprezentációja <span id="hét-visszalépéses-keresés-backtracking-és-heuristikák"></span> === 40. hét: Visszalépéses keresés (Backtracking) és heuristikák === * A backtracking lényege: próbálkozás és visszalépés – a keresési fa teljes bejárása minden lehetőség kipróbálásával<br /> * Klasszikus backtracking példák: n királynő probléma (8 királynő sakkfeladvány általános esetre), Sudoku megoldó algoritmus vázlata<br /> * Metszés (pruning) technikák: hogyan gyorsítható a backtracking ésszerű vágásokkal (pl. n-királynőnél azonos oszlopba vagy átlóba nem helyezünk királynőt)<br /> * Gyakorló feladat: egy kombinatorikus probléma megoldása backtrackinggel (pl. összes permutáció generálása egy számhalmazra, majd szűrés egy feltétellel) <span id="hónap-további-algoritmusok-és-versenytechnikai-trükkök"></span> == 11. hónap: További algoritmusok és versenytechnikai trükkök == A tizenegyedik hónapban kiegészítjük az algoritmusok tárházát néhány további fontos témával, valamint elkezdjük a kifejezetten versenyprogramozási technikák és trükkök megismerését. Sorra kerülnek a mohó algoritmusok (greedy) alapelvei és tipikus esetei, a szöveges algoritmusok (például mintaillesztés hatékony módszerei), valamint néhány matematikai algoritmus, amelyek gyakran felbukkannak versenyfeladatokban. Ezek a témák teljessé teszik az algoritmikai eszköztárat és felkészítik a hallgatókat a változatos feladattípusokra. <span id="hét-mohó-algoritmusok-greedy-és-alkalmazásaik"></span> === 41. hét: Mohó algoritmusok (Greedy) és alkalmazásaik === * A mohó stratégia lényege: mindig a pillanatnyilag optimális döntés meghozatala a globális optimum reményében<br /> * Tipikus példa: intervallumütemezési probléma – a lehető legtöbb nem átfedő intervallum kiválasztása adott időszakból mohó algoritmussal (rendezés befejezési idők szerint)<br /> * Kontrapélda: ahol a mohó algoritmus nem ad optimális megoldást (pl. pénzérmék rendszere, ha nem “kánonikus”, ahol a mohó nem működik minden összegre)<br /> * Gyakorlati feladat: tevékenység-kiválasztási probléma implementálása (feladatok kezdési és befejezési idővel), illetve az érmés probléma megvizsgálása mohó vs. DP megoldással <span id="hét-szöveges-algoritmusok-string-keresés"></span> === 42. hét: Szöveges algoritmusok (string keresés) === * Egyszerű mintaillesztési feladat: adott szövegen belül keresni egy adott mintát (részsztringet) – naiv algoritmus és annak <code>O(n*m)</code> bonyolultsága (n: szöveg hossza, m: minta hossza)<br /> * Hatékonyabb mintaillesztés: '''Knuth–Morris–Pratt (KMP)''' algoritmus alapötlete, prefix függvény (lps array) jelentése és használata; KMP komplexitása <code>O(n+m)</code><br /> * Hash alapú keresés említése: Rabin–Karp algoritmus, mint alternatív megközelítés (görgető hash, ütközések lehetősége)<br /> * Példafeladat: keressük meg egy rövidebb string összes előfordulását egy hosszú szövegben KMP algoritmussal, és hasonlítsuk össze a lépések számát a naiv kereséssel <span id="hét-matematikai-alapok-a-versenyprogramozásban"></span> === 43. hét: Matematikai alapok a versenyprogramozásban === * Prímszámok és prímszámtesztelés: egyszerű osztókeresés vs. '''Eratosthenész szitája''' (Sieve of Eratosthenes) nagy N-ig; prímszámok generálása hatékonyan<br /> * Legnagyobb közös osztó (Greatest Common Divisor – GCD) és legkisebb közös többszörös (LCM): Euklideszi algoritmus GCD meghatározására, LCM kiszámítása GCD segítségével<br /> * Gyors hatványozás (fast exponentiation) moduláris aritmetikában: ismételt négyzetre emelés módszere, hatványozás <code>O(log e)</code> időben; moduláris hatvány számítása (pl. nagy kitevők gyors számítása mod M)<br /> * Kombinatorikai alapok: faktoriális és binomiális együtthatók (n choose k) számítása iteratívan vagy DP-vel; modulo melletti számolás (nagy számok kezelése modként, túlcsordulás elkerülése)<br /> * Példák: prímszámok kiszűrése 1000000-ig szitával, két szám GCD-jének és LCM-jének kiszámítása, <code>a^b mod m</code> gyors kiszámítása, Pascal-háromszög felépítése 𝑛 sorig <span id="hét-haladó-adatszerkezetek-a-versenyfeladatokhoz"></span> === 44. hét: Haladó adatszerkezetek a versenyfeladatokhoz === * '''Szegmentfa''' (Segment Tree) alapelve: tartomány-lekérdezések (pl. intervallumösszeg, minimum) és frissítések hatékony (<code>O(log n)</code>) végrehajtása egy tömb adaton<br /> * Egyszerűbb alternatíva bizonyos feladatokra: '''Fenwick-fa''' (Binary Indexed Tree, BIT) bemutatása és összehasonlítása a szegmentfával (implementációs egyszerűség vs. sokoldalúság)<br /> * Tipikus alkalmazás: dinamikusan változó adathalmaz kezelése, ahol gyakoriak az elemmódosítások és részösszeg-lekérdezések (pl. pontértékek frissítése és prefixösszeg lekérdezése)<br /> * (Emlékeztető) Union-Find újra: tipikus használata versenyfeladatban (pl. összefüggő komponensek vizsgálata, halmazok egyesítése műveletsorozatok alapján)<br /> * Gyakorló feladat: szegmentfa vagy Fenwick-fa implementálása egy egyszerű problémára – például egy tömb részösszegének gyors lekérdezése és elemeinek módosítása különböző időpontokban <span id="hónap-versenyprogramozási-stratégiák-és-projektmunka"></span> == 12. hónap: Versenyprogramozási stratégiák és projektmunka == Az utolsó hónap a megszerzett tudás gyakorlati alkalmazására és a versenyprogramozási készségek csiszolására koncentrál. A hallgatók különböző nehézségű programozási feladatokat oldanak meg, miközben stratégiákat tanulnak a versenyhelyzetek hatékony kezelésére. Szó esik arról is, hogyan kell egy versenyfeladatot elemezni, megtervezni a megoldást, beosztani az időt, valamint hogyan lehet a kódot gyorsan ellenőrizni és hibákat javítani. Emellett egy záró projekt keretében a hallgatók komplex feladatot oldanak meg, amely integrálja a tanult algoritmusokat és technikákat, hasonlóan egy valós fejlesztési projekthez. <span id="hét-feladatok-elemzése-és-megoldástervezés-versenystratégia"></span> === 45. hét: Feladatok elemzése és megoldástervezés (versenystratégia) === * Feladat értelmezése versenyen: hogyan érdemes egy versenyfeladat szövegét gyorsan átolvasni és a lényeget kiemelni (bemenet/kimenet formátum, elvárások)<br /> * Követelmények és korlátok elemzése: a bemeneti méretekből algoritmus választása (pl. ha N ≤ 100, megengedhető lehet egy <code>O(N^2)</code> megoldás is, de N = 10^6 esetén hatékonyabb kell)<br /> * Megoldási stratégia kidolgozása: feladat részekre bontása, példákon tesztelés papíron (kézi számolás kis esetekre), megfelelő adatstruktúra és algoritmus kiválasztása a részegységekhez<br /> * Pszedokód vagy folyamatábra készítése a bonyolultabb feladatokhoz, mielőtt kódot írnánk – a tervezés fontossága a kapkodás helyett <span id="hét-hatékony-kódolás-és-hibakeresés-versenykörnyezetben"></span> === 46. hét: Hatékony kódolás és hibakeresés versenykörnyezetben === * Gyors és megbízható kódolás gyakorlása: ismerős minták, sablonkódok használata (pl. gyors beolvasó függvény, tipikus ciklusszerkezetek) a rutin műveletekhez<br /> * Bemenet/kiement optimalizálás nagy adatmennyiségnél: <code>ios::sync_with_stdio(false); cin.tie(NULL);</code> használata a <code>cin/cout</code> gyorsítására, szükség esetén C stílusú scanf/printf bevetése<br /> * Saját tesztesetek készítése és futtatása kódolás közben: lefedni a szélsőséges eseteket (minimális, maximális bemenet, speciális esetek: üres halmaz, negatív értékek, stb.)<br /> * Gyors hibakeresés: tipikus hibaforrások (tömb túlindexelés, nullpointer, inicializálatlan változó, egész túlcsordulás, végtelen ciklus) felismerése; debug output használata (ideiglenes <code>cout</code> a kritikus pontokon) a hiba izolálására <span id="hét-versenyszimuláció-és-időbeosztás"></span> === 47. hét: Versenyszimuláció és időbeosztás === * Szimulált programozó verseny lebonyolítása: a hallgatók számára 2-3 órás, több feladatból álló házi verseny szervezése az elsajátított ismeretek gyakorlására<br /> * Időbeosztási stratégia versenyen: feladatok gyors áttekintése az elején, priorizálás (könnyű feladatok előre vétele a biztos pontokért, nehéz feladatok időigényének felmérése)<br /> * Stresszkezelés és koncentráció: tippek verseny közbeni leblokkolás ellen (ha elakad, kis szünet vagy feladatváltás; folyamatos időellenőrzés, hogy ne ragadjunk bele egy megoldásba túl hosszan)<br /> * A szimuláció utáni kiértékelés: megoldások összehasonlítása, közös megbeszélés az esetleges más megoldási lehetőségekről, tanulságok levonása a versenyhelyzetből <span id="hét-záró-projekt-és-összefoglalás"></span> === 48. hét: Záró projekt és összefoglalás === * '''Záró projektmunka''': egy nagyobb szabású program vagy komplex algoritmikus feladat megvalósítása, ami integrálja a tanultakat. (Példa: egy mini “online judge” rendszer részegységeinek lefejlesztése, vagy egy összetett probléma megoldása, amely több algoritmust igényel – pl. útvonaltervező program grafikus felülettel, ami gráfalgoritmust és OOP-t is használ)<br /> * A projekt tervezése és megvalósítása: követelmények meghatározása, a feladat felosztása részfeladatokra, verziókezelés alapjai (egyszerű git használat a projektben), csapatmunka (ha páros vagy csoportos projekt) megszervezése<br /> * A kódoptimalizálási szempontok alkalmazása a projektben: tiszta struktúra, dokumentáció és kommentelés, megfelelő algoritmusok kiválasztása az egyes részfeladatokhoz, futási idő- és memória-profilozás a kész programon<br /> * Visszatekintés és összegzés: mely területeken fejlődtek a legjobban a hallgatók, milyen további témák felé érdemes nyitni (pl. haladó algoritmusok: grafikus algoritmusok, mesterséges intelligencia alapok, vagy a C++ újabb standardjainak funkciói), hangsúlyozva az élethosszig tartó tanulás fontosságát a programozásban '''Összegzés:''' Az egyéves tanterv elvégzésével a hallgatók magabiztosan mozognak a C++ nyelvben, ismerik annak alap- és haladó funkcióit, valamint széles körű algoritmikai tudásra tettek szert. A versenyfeladatok megoldásán edződve képessé válnak hatékonyan elemezni a problémákat, megtervezni az algoritmusokat és optimalizált kódot írni a megoldáshoz. Ez a tanmenet megalapozza nemcsak a versenyprogramozásban való sikeres részvételt (például egyetemi programozó versenyeken, online versenyeken), hanem a szoftverfejlesztői munka során felmerülő kihívások kezelését is. Fontos kiemelni, hogy a programozásban való jártasság folyamatos gyakorlást igényel – az egy év anyagának elsajátítása után is érdemes rendszeresen további versenyfeladatokat megoldani, új projekteket indítani, és nyomon követni a C++ és az algoritmusok fejlődését a szakmai naprakészség érdekében. {{engl}} {{C++ programming language}} {{Programming languages}} 4feb9rz06jzsvlwxdnsh92xhanwbl50 0 804389 3523809 3496059 2026-07-10T19:47:17Z Neriassel 28746 eltévedt, wikipédára való tartalom jelölése törlésre 3523809 wikitext text/x-wiki {{azonnali|nem szótárcikk, ez az angol wikipédiára való|[[Szerkesztő:Neriassel|Neriassel]] ([[Szerkesztővita:Neriassel|vita]]) 2026. július 10., 21:47 (CEST)}} [[File:Glen_Beck_and_Betty_Snyder_program_the_ENIAC_in_building_328_at_the_Ballistic_Research_Laboratory.jpg|thumb|ENIAC]] {{engfn}} # {{label|en|informatika}} [[számítástechnika története]] ---- <span id="a-számítástechnika-története"></span> = A számítástechnika története = <span id="es-évek-az-elektronikus-számítógépek-hajnala"></span> == 1940-es évek – Az elektronikus számítógépek hajnala == ''Az ENIAC számítógép (1946) egyike volt az első teljesen elektronikus, digitális számítógépeknek, amelyet elsősorban ballisztikus számításokra használtak az amerikai hadseregben.'' <span id="találmányok-és-első-használatok"></span> === Találmányok és első használatok === A második világháború időszakában jelentek meg az első '''programozható számítógépek'''. 1941-ben a német mérnök, '''Konrad Zuse''' megépítette a ''Z3'' gépet, amely a világ első működő programvezérelt számítógépe volt – bináris számrendszert alkalmazott, lebegőpontos számábrázolással és 64 szó kapacitású memóriával. Ugyanekkor az Egyesült Államokban '''John Atanasoff''' és '''Clifford Berry''' kifejlesztették az ''Atanasoff–Berry Computer (ABC)'' gépet, amely az első elektronikus számológép volt lineáris egyenletrendszerek megoldására. Az ABC különlegessége az volt, hogy kondenzátor-alapú, regeneratív memóriát használt (ez tekinthető az első ''RAM'' megvalósításnak). A titkosítás terén az Egyesült Királyságban, a Bletchley Parkban, '''Max Newman''' és csapata 1943-ban üzembe helyezte a ''Heath Robinson'' nevű elektromechanikus számolóművet, amely a náci rejtjelek megfejtését segítette. Ezt követte 1943 végén a '''Tommy Flowers''' által épített ''Colossus'' számítógép, amely az első teljesen elektronikus, digitális számítógép volt – igaz, programozhatósága korlátozott és kifejezetten a Lorenz-kód feltörésére tervezték. A Colossus 1500 elektroncsövet tartalmazott és másodpercenként ~25 000 karakter feldolgozására volt képes, jelentősen felgyorsítva a kódfeltörést. Mivel ez a munka szigorúan titkos volt, a Colossus létezését évtizedekig homály fedte, így nem befolyásolta az Egyesült Államokban zajló fejlesztéseket. 1946-ban az USA-ban bemutatták az ''ENIAC'' gépet (Electronic Numerical Integrator and Computer), amely az első nagyszabású, általános célú, teljesen elektronikus számítógép volt. Az ENIAC 18 000 elektroncsővel működött, 30 tonnát nyomott és 160 kW energiát fogyasztott. Összetett ballisztikai számításokat és a hidrogénbomba-fejlesztéshez kapcsolódó numerikus feladatokat végzett, nagyjából 5000 művelet/s sebességgel. Programozása kezdetben kézi átkötésekkel és kapcsolóállításokkal történt – tehát nem volt még tárolt program elve szerint működő gép. 1948-ban azonban a '''Manchester Baby''' (Small-Scale Experimental Machine) az Egyesült Királyságban elsőként futtatott programot egy ''tárolt programú számítógépként'', a memória mátrixában eltárolva mind az adatokat, mind az utasításokat. 1949-re pedig '''Maurice Wilkes''' és csapata Cambridge-ben üzembe helyezte az ''EDSAC'' gépet, amely az első teljesen működő ''Neumann-elvek'' szerint tervezett számítógép lett. E fejlesztések lefektették a modern számítógépek architektúrájának alapjait. <span id="hardverrendszerek-és-processzorok"></span> === Hardverrendszerek és processzorok === A korai elektronikus számítógépek ''elektroncsövekre'' és ''relékre'' épültek. A Z3 és az ENIAC is több ezer elektroncső segítségével végezte a logikai műveleteket. Ezek a gépek hatalmas termeket töltöttek meg a hardver elemeivel és jelentős hőtermeléssel, energiafogyasztással jártak. A memória technológiája kezdetben mechanikus vagy elektronikus késleltető elem volt: például higany késleltetővonalak (higanycsövek) vagy kondenzátorok formájában tárolták a biteket, amelyeket folyamatosan frissíteni kellett (regeneratív memória az ABC-ben). '''John von Neumann''' 1945-ös híres jelentése, az ''First Draft of a Report on the EDVAC'', már leírta a ''tárolt program'' koncepcióját és a Neumann-architektúra elvét, amely szerint az utasítások és adatok ugyanabban a memóriában tárolhatók. Ez óriási előrelépést jelentett a hardver architektúrában: lehetővé tette a programok elektronikus tárolását és módosítását, megszüntetve a gép fizikai újrakábelezésének igényét az egyes feladatok között. 1947 decemberében a Bell Labs kutatói – '''William Shockley, John Bardeen és Walter Brattain''' – feltalálták a ''tranzisztort'', egy új szilárdtest-eszközt, amely az elektroncsöveknél jóval kisebb méretű és megbízhatóbb kapcsolóelemnek bizonyult. Bár ez a forradalmi találmány a ’40-es években még nem jelent meg a számítógépekben, megalapozta a későbbi generációs hardver fejlődését. Ugyanebben az évben, 1947-ben fejlesztette ki '''Kathleen Booth''' az első összeállító nyelvet (''assembly language'') a Birkbeck College-ban, Londonban – ezzel megjelent az igény, hogy a hardver szintű gépi kódnál emberközelibb formában is lehessen programozni. <span id="operációs-rendszerek"></span> === Operációs rendszerek === A 1940-es évek számítógépein még nem léteztek mai értelemben vett '''operációs rendszerek'''. A programokat gyakran közvetlenül gépi kódban vitték be (kapcsolótáblák, lyukkártyák vagy papírszalagok segítségével), és a gépek egyszerre jellemzően csak egy feladatot futtattak. A '''programozók''' maguk állították össze a végrehajtandó utasítássorozatot és indították el a számítógépet. A futás során minden erőforrás (processzoridő, memória) egy programé volt, így nem merült fel a többfeladatos üzem vagy erőforrás-kezelés igénye. A korabeli gépeken a programbetöltést és -vezérlést egyszerű kézi vagy vezérlőáramkörök (monitor programok) látták el, de ezek még nem alkottak külön szoftveres rendszert. Például az EDSAC számítógéphez '''Wilkes''' kidolgozta az ún. ''initial orders''-t (kezdő utasításokat) – ez egy kis program volt a gép memóriájában, amely megkönnyítette a lyukszalagról való betöltést és ezzel primitív vezérlő szoftverként működött. Összességében azonban az 1940-es években az operációs rendszer fogalma még nem létezett: a számítógépek közvetlen vezérlése és a futtatás menedzsmentje minden esetben a felhasználók és mérnökök feladata volt. <span id="programozási-nyelvek-és-fejlesztői-eszközök"></span> === Programozási nyelvek és fejlesztői eszközök === A számítástechnika hajnalán a programozás alapvetően ''gépi kódban'', azaz bináris vagy decimális műveleti kódok és memóriarekesz-címek sorozataként történt. A programozók – többnyire matematikusok és mérnökök – kézzel állították össze a gép utasításait. Az első áttörés ebben a '''assembly''', azaz assembly nyelv megjelenése volt: 1947-ben '''Kathleen Booth''' megalkotta az első assembly nyelvet, amely mnemonikus kódokkal (ember számára értelmezhető rövidítésekkel) helyettesítette a gépi kód bináris utasításait. Ez hatalmas segítséget jelentett, mert a programkód olvashatóbbá és könnyebben karbantarthatóvá vált. Emellett az assembly programokat egy ''assembler'' nevű szoftver fordította át gépi kóddá – ez tekinthető az első fejlesztői eszközök egyikének. Fontos megemlíteni '''Grace Murray Hopper''' nevét is, aki a ’40-es években a Harvard Mark I electromechanikus számítógépen dolgozott. 1947-ben Hopper dokumentálta az első ismert ''számítógépes “bugot”'': a Mark II egyik reléjébe szorult molylepkét, amely hibát okozott. Az eseményt tréfásan bejegyezték a naplóba mint „az első igazi ''bug''” – innen eredeztetik a ''debugging'' (hibakeresés) kifejezés használatát a szoftverfejlesztésben. Bár a “bug” szó technikai hibára már Thomas Edison idejében is használatos volt, a hopperi anekdota segített népszerűsíteni a kifejezést a számítástechnika területén. <span id="alkalmazási-területek"></span> === Alkalmazási területek === Az 1940-es években az akkor még szűk körben elérhető számítógépek főként '''tudományos és katonai célokra''' szolgáltak. A Colossus gépek a német hadsereg rejtjelfejtésében játszottak kulcsszerepet, lerövidítve a titkosított üzenetek megfejtésének idejét és ezzel hozzájárulva a szövetségesek hírszerzési sikereihez. Az ENIAC-ot eredetileg az amerikai hadsereg ballisztikus lövedék-pályatáblázatainak kiszámítására tervezték: a háború alatt ezeket a számításokat emberi számítók végezték, de a számítógép jelentősen felgyorsította a folyamatot. A háború után az ENIAC-ot tudományos kutatásokra használták, például a hidrogénbomba fejlesztéséhez szükséges szimulációk futtatására. 1949-ben az Egyesült Királyságban a '''Lyons cég LEO I''' számítógépe futtatta az első üzleti alkalmazást (bérszámfejtés) – ezzel kezdetét vette a számítógépek üzleti (kereskedelmi) alkalmazása. <span id="fontos-idézetek-és-koncepciók"></span> === Fontos idézetek és koncepciók === A korszakban formálódtak meg a számítástechnika alapvető elméleti koncepciói. '''Alan Turing''' brit matematikus már 1936-ban leírta az ''univerzális Turing-gép'' elvét, ami elméleti modellként megalapozta a számítógép fogalmát. 1950-ben Turing publikálta gondolatait a ''gépi értelem'' lehetőségéről, és felvetette a híres kérdést: „''Gondolkodhatnak-e a gépek?''”. Ebben a cikkben fogalmazta meg azt a kísérletet is, amelyet később ''Turing-tesztként'' ismerünk – bár ez már 1950-es esemény, a gondolat a ’40-es évek végének intellektuális légkörében gyökerezett. A Neumann-elvek (köztük a tárolt program koncepciója) a korszak végére széles körben elfogadottá váltak a szakemberek körében. Egy sokat idézett (bár vitatott hitelességű) jóslat 1943-ból szintén jól szemlélteti a kort: '''Thomas Watson''', az IBM akkori elnöke állítólag azt mondta, ''„talán öt darab számítógépre lehet igény világszerte”''. Függetlenül attól, valóban hangzott-e ez el, az idézet gyakran szerepel a korai számítógépek korlátozott felhasználhatóságával kapcsolatos vélekedések példájaként. Ugyancsak beszédes '''Howard H. Aiken''' 1950-ben megjelent nyilatkozata: „''Nagyobb problémákat kell kitalálnunk, ha azt akarjuk, hogy ezeknek a gépeknek legyen mit csinálni''” – utalva arra, hogy a korabeli számítógépek már a meglévő számítási feladatokat túl gyorsan megoldják. <span id="nyílt-problémák-és-versenyek"></span> === Nyílt problémák és versenyek === Az 1940-es években a számítástechnika legnagyobb nyílt problémája maga a '''megbízható és univerzális számítógép megalkotása''' volt. A korai gépek gyakran meghibásodtak (főként az elektroncsövek gyakori kiégése miatt) és programozásuk rendkívül időigényes volt. Az is nyitott kérdés volt, hogy lehet-e a számítógépeket a puszta számításnál összetettebb feladatokra használni, például utasításokkal ''önműködően'' irányítani egy folyamatot. Ez a probléma vezetett a tárolt programú vezérlés koncepciójához, amelyet Neumann János megoldott elméletben, és a késő ’40-es évekre megvalósult gyakorlatban is. A mesterséges intelligencia terén is fogalmazódtak meg kihívások: Turing említett gondolatkísérlete, a Turing-teszt felvetette egy olyan jövő versenyének lehetőségét, ahol egy gép és egy ember intelligens viselkedését kell megkülönböztetni. Bár ilyen verseny a ’40-es években még nem létezett, ez a felvetés évekkel később (1991-től a Loebner-díj keretében) valódi verseny formájában is megjelent. Összességében a 40-es évek végére a számítógépek terén a legfontosabb nyílt kérdés az volt, milyen mértékben lehet ezeket a gépeket általános célúvá tenni, és hol vannak a határai annak, amit géppel el lehet végezni – a következő évtizedek ezeket a kérdéseket kezdték el megválaszolni. <span id="es-évek-az-első-generációs-számítógépektől-a-tranzisztorokig"></span> == 1950-es évek – Az első generációs számítógépektől a tranzisztorokig == <span id="találmányok-és-első-használatok-1"></span> === Találmányok és első használatok === Az 1950-es évek elején a számítógépek kiléptek a laboratóriumokból és megkezdődött az '''első kereskedelmi gépek''' kora. 1951 márciusában üzembe helyezték az első kereskedelmileg sikeres számítógépet, az ''UNIVAC I''-et, amelyet '''J. Presper Eckert''' és '''John Mauchly''' tervezett. Az UNIVAC volt az első általános célú elektronikus számítógép, amelyet üzleti és adminisztratív adatok (szövegek, számok) feldolgozására is szántak, nem csak tudományos számításokra. Ugyanebben az évben, 1951-ben a brit '''Lyons''' cég ''LEO I'' számítógépe futtatta az első üzleti szoftvert (egy fizetési jegyzék feldolgozását), bizonyítva, hogy a számítógépek a kereskedelmi szektorban is hasznosíthatók. A kormányzati és katonai szférában is egyre több alkalmazás jelent meg: 1951-ben '''Jay Forrester''' és csapata a MIT-en befejezte a ''Whirlwind'' számítógépet, amely az első '''valós idejű számítógép''' volt és interaktív módon, katódsugaras kijelzőn keresztül lehetett vezérelni. A Whirlwind tapasztalataira építve az amerikai légierő megalkotta a ''SAGE'' (Semi-Automatic Ground Environment) légvédelmi rendszert, amely a ’50-es évek végére a számítógépes hálózatba kötött radarfigyelés és -irányítás úttörőjévé vált. 1950-ben '''Alan Turing''' publikációja (amely később a ''Turing-teszt'' nevet kapta) felvetette a gépi intelligencia lehetőségét és megalapozta a mesterségesintelligencia-kutatás elméleti kereteit. 1956 nyarán Dartmouth College-ban egy konferencián neves kutatók (köztük '''John McCarthy, Marvin Minsky''' és mások) találkoztak, ahol megszületett a ''„mesterséges intelligencia”'' kifejezés, és ezzel elindult az AI, mint kutatási terület – ennek eredményeképp a ’50-es évek végén például '''Newell, Simon és Shaw''' kifejlesztették a ''Logic Theorist'' és a ''General Problem Solver'' programokat, melyek az emberi gondolkodás szimulálására tettek kísérletet. Az évtized során a számítógépek egyre nagyobb teljesítményűek lettek, ám ekkor még mindig ''elektroncsöveket'' használtak (ezért hívjuk ezeket ''első generációs'' számítógépeknek). 1959-re a világ számos pontján működtek elektroncsöves számítógépek; ebben az évben jelent meg például az első japán elektronikus számítógép, a ''FUJIC'', illetve a Szovjetunióban is fejlesztettek saját gépeket (MESM, BESZM stb.). 1959 és 1964 között gyártott gépeket szokás az első generációba sorolni, ekkorra kb. 2000 számítógép működött világszerte. <span id="hardverrendszerek-és-processzorok-1"></span> === Hardverrendszerek és processzorok === A ’50-es évek közepéig a számítógépek elektroncsöves technológián alapultak. Ezek a gépek hatalmasak voltak és rendkívül sok hőt termeltek, ami gyakori meghibásodásokhoz vezetett. 1954-ben azonban egy forradalmi változás kezdődött: az elektroncsöveket fokozatosan felváltották a ''tranzisztorok''. Az első tranzisztoralapú számítógépek közé tartozott például a '''TX-0''' (1956, MIT), amely kísérleti gépként demonstrálta, hogy egy számítógép felépíthető teljes egészében tranzisztorokkal. 1959-re a számítógépek második generációja, a '''tranzisztoros gépek''' megjelentek: kisebbek, gyorsabbak és megbízhatóbbak lettek. Az IBM 1959-ben jelentette be az ''IBM 7090'' gépet, ami tranzisztoros változata volt a korábbi 709-es csöves számítógépnek, és sokkal nagyobb teljesítményt nyújtott. Egy másik fontos hardver-innováció a memória terén történt: az elektroncsöves és késleltetővonalas memóriákat felváltották a '''mágneses magtárak'''. 1953-ra a mágneses ferritgyűrűkből álló ''magtár'' memória standarddá vált a számítógépekben (például a Whirlwind-ben is ezt alkalmazták). A magtárak megbízható, véletlen elérésű memóriát biztosítottak, amely megőrizte tartalmát áramkimaradás esetén is. Ez jelentősen megnövelte a gépek teljesítményét és használhatóságát. 1958-ban új fejezet nyílt a hardver történetében: '''Jack Kilby (Texas Instruments)''' és '''Robert Noyce (Fairchild Semiconductor)''' egymástól függetlenül feltalálták az ''integrált áramkört (IC)'', amely több tranzisztort és áramköri elemet egyetlen félvezető lapkára integrált. Bár az integrált áramkörök a ’50-es évek végén még kezdetlegesek voltak és a számítógépekben csak a ’60-as években terjedtek el, ez a találmány megalapozta a későbbi mikroprocesszorok és modern számítógépek lehetőségét. Az integrált áramkörök megjelenésével beszélhetünk a ''harmadik generációs'' számítógépek kezdetéről, bár ennek kibontakozása inkább a következő évtizedre esik. <span id="operációs-rendszerek-1"></span> === Operációs rendszerek === Az 1950-es évek elején a számítógépek még mindig egy felhasználós, egyprogramos üzemmódban működtek. A programokat lyukkártyákon vagy szalagon adták be, és a gépek addig futtatták őket, amíg véget nem értek. Az évtized közepén azonban megjelent az igény a hatékonyság növelésére: a számítógépidő drága volt, ezért kifejlesztették az első ''soros feldolgozó (batch processing)'' rendszereket. 1956-ban az '''IBM''' egyik gépén futott az első egyszerű ''batch monitor'' program: ez volt a '''GM-NAA I/O''', amelyet az General Motors megbízásából írtak az IBM 701 számítógépre. A GM-NAA I/O alapvetően egy kezdetleges operációs rendszer volt, amely sorban egymás után betöltötte és lefuttatta a lyukszalagon sorakozó feladatokat, emberi beavatkozás nélkül. A ’50-es évek végére az operációs rendszerek előfutáraiként olyan szoftverek jelentek meg, amelyek automatizálták a feladatok ütemezését és az eszközkezelést. 1959-ben az '''MIT''' kifejlesztette a ''Compatible Time-Sharing System'' (CTSS) elődjét megalapozó koncepciókat, bár maga a CTSS csak 1961-ben indult el. Összességében a ’50-es évek végén az operációs rendszerek még gyerekcipőben jártak: a legtöbb gép csak feladatkezelő monitorprogramokkal rendelkezett, de a következő évtizedben ugrásszerű fejlődés indult, ahogy a gépek teljesítménye és felhasználói száma nőtt. <span id="programozási-nyelvek-és-fejlesztői-eszközök-1"></span> === Programozási nyelvek és fejlesztői eszközök === A programozás forradalmi változásokon ment keresztül az 1950-es években. Míg a korai években az assembly nyelv jelentett előrelépést, hamar felismerték, hogy magasabb szintű, az emberi gondolkodáshoz közelebb álló '''programozási nyelvekre''' van szükség. 1957-ben az '''IBM''' mérnöke, '''John Backus''' kifejlesztette a ''FORTRAN'' nyelvet (Formula Translator), amely kifejezetten tudományos és mérnöki számításokhoz készült. A FORTRAN volt az első széles körben használt '''magasszintű programozási nyelv''', és fordítóprogramja hatékony kódot állított elő, így a tudósok és mérnökök körében gyorsan népszerű lett. Ezt követte 1958-ban a '''LISP''' nyelv ('''John McCarthy''' és társai) – a mesterséges intelligencia kutatás igényeire szabva, a listák és rekurzív adattípusok kezelésével. 1959-ben pedig '''Grace Hopper''' közreműködésével létrejött a ''COBOL'' (Common Business-Oriented Language), amelyet üzleti adatok feldolgozására optimalizáltak. A COBOL nagy előnye az volt, hogy hasonlított az angol nyelvhez, így a kormányzati és üzleti alkalmazások programozását szélesebb kör számára tette hozzáférhetővé. A fejlesztői eszközök is fejlődtek: megjelentek az első '''fordítóprogramok''' (compiler-ek), melyek automatikusan lefordították a magasszintű nyelveken írt programokat gépi kódra. A FORTRAN fordítója (1957) mérföldkő volt, bizonyítva, hogy a gépi kódú programok hatékonysága elérhető automatikus fordítással is. 1952-ben Grace Hopper már elkészítette az A-0 nevű fordítóprogramot, amely a gépi kódú szubrutinokat linkelte össze magasabb szintű utasítások alapján – egyesek ezt tekintik az első igazi compilernek. A ’50-es évek végére a programozók rendelkezésére álltak assembler-ek, compiler-ek, és kezdetleges ''debuggerek'', így a szoftverfejlesztés egyre inkább különvált a hardver építésétől. <span id="alkalmazási-területek-1"></span> === Alkalmazási területek === Ebben az évtizedben a számítógépek alkalmazása rohamosan bővült. Továbbra is fontosak maradtak a '''tudományos számítások''': a FORTRAN megjelenése például forradalmasította a numerikus szimulációkat a mérnöki és fizikai kutatásokban. Szuperszonikus repülőgépek tervezésénél, atomfizikai számításoknál már számítógépet használtak a bonyolult differenciálegyenletek megoldására. Az '''üzleti életben''' a számítógépek lassan kezdtek meghonosodni. A COBOL nyelv és az olyan számítógépek, mint az UNIVAC, megmutatták, hogy a könyvelés, raktárkezelés, banki nyilvántartások automatizálhatók. 1954-ben egy GE 225 számítógépen futott az első '''banki információs rendszer''' (a Bank of America számára készült ERMA rendszer, bár teljes üzembe csak 1961-ben állt), ami feldolgozta a csekkeket és frissítette a számlaegyenlegeket. A '''kormányzati szektorban''' és a nagyvállalatoknál a számítógépek elsősorban adatfeldolgozásra és nyilvántartásra találtak alkalmazást. Például az USA Népszámlálási Hivatala is UNIVAC gépeket használt az 1950-es népszámlálási adatok feldolgozására. A katonai alkalmazások között a SAGE légvédelmi rendszer mellett megjelent a ballisztikus rakéták navigációját segítő számítógépes rendszer is (a ''NAVSAT'' elődje), valamint a hadseregen belül logisztikai és kommunikációs feladatokra is kezdték bevetni az elektronikus számítógépeket. Az 1950-es évek végén egy különleges alkalmazási terület is felbukkant: a '''számítógépes zene'''. 1957-ben '''Max Mathews''' a Bell Labs-nál kifejlesztette a Music I szoftvert, mely lyukszalagról olvasott kottát és hangot generált – ez volt a számítógéppel komponált zene kezdete. 1951-ben Manchesterben a Ferranti Mark 1 gép pedig egyszerű dallamokat játszott le – ezek a legrégebbi ismert számítógép által generált zenei felvételek. <span id="fontos-idézetek-és-koncepciók-1"></span> === Fontos idézetek és koncepciók === A ’50-es években vált világossá, hogy a számítógépek rendkívül gyors fejlődése új kihívásokat és koncepciókat szül. 1952-ben '''John von Neumann''' azt nyilatkozta, hogy ''„számunkra, akik láttuk a számítógépek születését, nehéz elképzelni, hova vezet mindez”''. Ez a bizonytalanság a szakemberek között is jelen volt: sokan vitatták, hogy a számítógépek alkalmasak lehetnek-e műfordításra, játékokban való gondolkodásra vagy akár gépi tanulásra. 1956-ban a Dartmouth konferencián '''Marvin Minsky''' optimistán kijelentette: ''„a mesterséges intelligencia problémáinak lényegét egy nyár alatt meg lehet oldani”''. Ez a túlzott optimizmus később, a ’60-as évek végére ''„AI-tél”'' néven emlegetett kiábránduláshoz vezetett, de a ’50-es évek közepén még nagy lendület és hit övezte az AI kutatást. A programozás terén '''Edsger Dijkstra''' 1957-ben (még Hollandiában) megalkotta az első fordítási algoritmust az ALGOL nyelvhez, és ezzel megalapozta a ''struktúrált programozás'' későbbi mozgalmát. '''Grace Hopper''' egyik híres idézete ebből az időből: ''„Nehéz meggyőzni az embereket, hogy a számítógép nem az ördög műve, csak azért, mert számolni tud”'' – utalva arra az attitűdre, amivel sok laikus vagy akár üzletember tekintett a számítógépekre: misztikus, bonyolult eszközként. <span id="nyílt-problémák-és-versenyek-1"></span> === Nyílt problémák és versenyek === Az 1950-es években a számítógépes világ számos nyílt problémával nézett szembe. Az egyik fő kihívás a '''megbízhatóság és skálázhatóság''' volt: hogyan lehet a gépeket kevésbé hibafogékonnyá tenni és egyszerre több feladatot futtatni. Ez a probléma ösztönözte az operációs rendszerek és a tranzisztoros hardver fejlesztését. A '''szoftverfejlesztés''' is problémákkal küzdött. Ahogy a programok bonyolódtak, egyre világosabbá vált, hogy a programozás módszertanát fejleszteni kell. A későbbi ''„szoftverválság”'' első jelei már mutatkoztak: nagy projekteknél csúszások és költségtúllépések voltak. Ennek előszelét a NATO 1968-as konferenciáján nevezték el szoftverválságnak, de az alapjai a ’50-es évek végén gyökereztek, amikor a COBOL és FORTRAN projektek kapcsán felmerült a dokumentáció és karbantarthatóság fontossága. A mesterséges intelligenciában nyílt kérdés volt, hogy vajon egy gép képes lehet-e például sakkozni emberi szinten. 1950-ben '''Claude Shannon''' írt egy tanulmányt a számítógépes sakkról, ami aztán versenyhelyzeteket inspirált: 1956-ban már rendeztek primitív számítógépes sakkversenyt (IBM vs. NSS programok között). Az igazi nagy '''verseny''' azonban ebben a korban még inkább elvi jellegű volt: ember vs. gép. 1956-ban az NSSCs (Nemzetközi Sakk Számítógép Konferencián) bemutatták az első sakkprogramokat, de gép még nem győzött le mesterszintű sakkozót. Ez a kihívás csak évtizedekkel később, 1997-ben oldódott meg, amikor az IBM Deep Blue legyőzte Garri Kaszparovot. Ugyancsak nyitott probléma volt a '''gépi fordítás''': 1954-ben egy orosz–angol gépi fordítási kísérlet (Georgetown-IBM kísérlet) biztató eredményt hozott, de hamar világossá vált, hogy a nyelv feldolgozása sokkal nehezebb feladat, semmint pár év alatt megoldható legyen – ez a probléma is velünk maradt még évtizedekig. Összességében a ’50-es évek végére a számítástechnika közössége számos ígéretet és ugyanakkor problémát látott maga előtt: a számítógépek egyre gyorsabbak és hasznosabbak lettek, de kérdés volt, hogyan lehet őket hatékonyan programozni, több feladatot párhuzamosan kezelni, és vajon meddig fokozható a teljesítményük – ezek a kérdések a következő évtizedek kutatásait meghatározták. <span id="as-évek-integrált-áramkörök-és-a-szoftverek-születése"></span> == 1960-as évek – Integrált áramkörök és a szoftverek születése == <span id="találmányok-és-első-használatok-2"></span> === Találmányok és első használatok === A 1960-as évekre a számítógépek második generációja – a tranzisztoros gépek – már kiforrott, és az évtized során átlépünk a '''harmadik generációba''', amit az ''integrált áramkörök (IC)'' alkalmazása jellemez. 1960-ban a Bell Labs kutatói megépítették az első működő '''MOSFET tranzisztort''' (fém-oxid-félvezető tranzisztort), ami később a modern mikroprocesszorok alapja lett. 1961-ben a '''Texas Instruments''' bemutatta az első integrált áramkörökre épülő kísérleti számítógépet, a ''Molecular Electronic Computer''-t, bizonyítva hogy az IC-technológia alkalmas számítógép építésére. Az évtized elején – 1964-ben – az '''IBM bemutatta a System/360 családot''', az első olyan számítógéprendszert, amely különböző méretű és teljesítményű modelleket kínált, de közös utasításkészlettel. Ez forradalmi volt, mert a korábbi években minden új számítógépmodellhez a szoftvereket újra kellett írni. A System/360 egységes platformot teremtett a kis és nagy gépek között, és ezzel az IBM dominánssá vált a mainframe piacon. A System/360 emellett 8 bites ''bájt'' egységet használt (ez a bájt definíciója itt rögzült ipari szabványként), és egy sor új technológiát vezetett be (például mikroprogramozást, tranzisztoros áramköröket, stb.). A ’60-as években a számítógépek megjelentek a '''kutatás''' számos területén és új alkalmazások születtek. 1965-ben üzembe állt a '''CDC 6600''', a világ első szuperszámítógépe, amelyet '''Seymour Cray''' tervezett a Control Data Corporationnél. A CDC 6600 1964-ben debütált és ~3 millió műveletet végzett másodpercenként, megelőzve minden korábbi gépet. Ez a gép vezette be a ''párhuzamos feldolgozás'' bizonyos elemeit (több funkcionális egységen keresztüli utasításkivitelezés), és évekig a leggyorsabb számítógép volt. Az évtized második felében, 1969-ben egy kis lépés az emberiségnek, nagy ugrás a számítástechnikának: az '''ARPANET''' projekt keretében létrejött az első számítógép-hálózat csírája. 1969. november 21-én sikerült összekapcsolni két távoli gépet (UCLA és Stanford), létrehozva az első két csomópontos hálózatot – ez lett az ARPANET magja. Bár ekkor még csak négy csomópontból állt a hálózat (1969 végére), az ARPANET a későbbi internet előfutára volt, és a ’60-as évek végén megszülettek a hálózati kommunikáció alapvető protokolljai és eszközei (pl. '''RFC 1''' – az első Request for Comments dokumentum 1969 áprilisában jelent meg, formalizálva a hálózati protokollok fejlesztését). <span id="hardverrendszerek-és-processzorok-2"></span> === Hardverrendszerek és processzorok === A hardver terén a ’60-as évek forradalmi újdonsága az '''integrált áramkörök''' egyre szélesebb körű alkalmazása volt. 1962-re a Manchesteri Egyetemen elkészült az ''Atlas'' számítógép, mely ugyan még tranzisztoros volt, de számos újításával – mint a párhuzamos feldolgozás, szimultán I/O műveletek és a ''virtuális memória'' – megelőlegezte a következő generáció képességeit. Az Atlas a világ egyik legerősebb gépe volt megjelenésekor, és bevezette a ''lapozást'' (paging) a memóriakezelésben, lehetővé téve a programok számára, hogy a fizikai memóriánál nagyobb memóriateret használjanak. 1965-re a tranzisztoros technológia csúcsra ért a ''miniszámítógépek'' megjelenésével: a '''Digital Equipment Corporation (DEC)''' kiadta a ''PDP-8'' gépet, ami az első kereskedelmileg sikeres miniszámítógépnek tekinthető. A PDP-8 relatíve olcsó ($18 000 körüli ár), kis helyigényű gép volt, melyet laborokban, egyetemeken és kisebb cégeknél is alkalmazni tudtak – ezzel elkezdődött a számítástechnika decentralizációja, nem csak óriási vállalatok engedhették meg maguknak a gépeket. 1969-ben a '''Honeywell''' bemutatta a ''Honeywell 316'' miniszámítógépet, amely integrált áramköröket használt, és a Bell Labs ezt a gépet alkalmazta az első '''programozható logikai vezérlő (PLC)''' létrehozására ipari folyamatok vezérléséhez (ez a ''Project MAC'' része volt). Eközben 1969-ben az '''Intel''' megkezdte első mikroprocesszorának fejlesztését, a 4-bites ''4004'' chip tervezését – bár maga a 4004 csak 1971-ben készült el, a ’60-as évek végén indult projekt volt a mikroprocesszor születésének előjátéka. A ’60-as évek közepétől a ''második generációs'' gépeket (tranzisztoros) fokozatosan felváltották a ''harmadik generációs'' gépek. Ez utóbbiakban már '''IC-ket''' alkalmaztak, ami nagyságrendi növekedést hozott az integráltságban és megbízhatóságban. Az IBM System/360 család, valamint a DEC újabb gépei (PDP-11, 1970 körül) mind integrált áramkörös logikával készültek. Az integrált áramkörök kezdetben ''kis integráltságú'' (SSI) és ''közepes integráltságú'' (MSI) chipeket jelentettek, melyeken néhány tíz vagy száz tranzisztor volt. A ’60-as évek végére megjelent a ''nagymértékben integrált áramkör'' (LSI), több ezer tranzisztorral – ennek köszönhetően a komplett processzorok a következő évtizedben már egy lapkára kerülhettek. <span id="operációs-rendszerek-2"></span> === Operációs rendszerek === A 1960-as években az operációs rendszerek terén hatalmas fejlődés zajlott: kialakultak a mai OS-ek alapvető funkciói – mint a többfeladatos működés, párhuzamos felhasználói elérés és a különböző hardver-erőforrások dinamikus kezelése. 1961-ben a '''MIT''' kifejlesztette a ''CTSS'' (Compatible Time-Sharing System) rendszert kísérleti jelleggel, amely 1961-ben demonstrálta, hogy egy számítógépet (IBM 7090) több felhasználó terminálokon keresztül egyszerre, időosztásos módon használhat. A ''time-sharing'', azaz időosztásos üzemmód forradalmasította az interaktív számítógép-használatot, hiszen már nem kellett órákat vagy napokat várni egy batch feladat eredményére – a felhasználók közvetlenül kommunikálhattak a géppel. 1964-ben a '''Dartmouth College'''-ban kifejlesztették a Dartmouth Time-Sharing System-et, és ennek részeként a BASIC programozási nyelvet, amely egyszerű szintaxisával a diákok interaktív tanítására szolgált. A BASIC interpreter futtatása egy időosztásos rendszeren lehetővé tette, hogy sok diák egyszerre programozzon egy központi gépen, ami a számítógépek oktatási alkalmazását erősen fellendítette. Az IBM System/360 bevezetésével párhuzamosan az IBM megalkotta az OS/360 operációs rendszert (1966-ra vált stabillá), ami már rendkívül összetett, többfeladatos OS volt: batch munkákat, spoolingot (perifériák közötti pufferelést) és különböző nyelvekhez fordítókat tartalmazott. Az OS/360 a megbízhatóság és az akkori hardver maximális kihasználása érdekében jött létre, és hozzájárult az ''„operációs rendszerek”'' fogalmának elterjedéséhez. A korszak talán legfejlettebb kísérleti OS-e a '''Multics''' (Multiplexed Information and Computing Service) volt, amelyet 1964-től kezdődően fejlesztett a MIT, a Bell Labs és a GE közösen. A Multics számos újdonságot vezetett be: dinamikus újrafordítás, fájlrendszer hierarchia, biztonsági védelem és egy akkor forradalmi koncepció: ''újrabelépő kernel'' moduláris felépítéssel. Bár a Multics végül csak korlátozott körben terjedt el, közvetlen hatása óriási volt – például inspirálta az 1969-ben megszületett '''UNIX''' operációs rendszert. 1969-ben a Bell Labs fiatal programozói, '''Ken Thompson és Dennis Ritchie''' létrehozták a UNIX első verzióját, kezdetben egy DEC PDP-7 gépen. A UNIX egyszerűbb volt a Multicsnál, de átvette annak sok jó ötletét, és a ’70-es évekre a UNIX vált a többfelhasználós operációs rendszerek etalonjává. Megjelent a rendszerhívások koncepciója, a fájlkezelés egységes elve (mindent fájlként kezelünk), és a csővezetékek (pipeline) ötlete is. A ’60-as évek végére tehát az operációs rendszerek már elérték azt a komplexitást, hogy a ''szoftver'' külön iparággá válhatott. <span id="programozási-nyelvek-és-fejlesztői-eszközök-2"></span> === Programozási nyelvek és fejlesztői eszközök === A 60-as évek hihetetlen pezsgést hoztak a programozási nyelvek terén. 1960-ban megjelent az '''ALGOL 60''', amely a struktúrált, blokkos programozás első valóban nemzetközi nyelve lett, és bevezette a máig használt szintaktikus elemek egy részét (begin-end blokkok, rekurzió stb.). Bár az ALGOL-t főleg az akadémiai és matematikai körök használták, hatása óriási volt a későbbi nyelvekre (Pascal, C, stb.). 1964-ben '''John Kemeny és Thomas Kurtz''' elkészítette a '''BASIC''' nyelvet (Beginner’s All-purpose Symbolic Instruction Code), kifejezetten az egyszerűség kedvéért, hogy diákok könnyen megtanulhassák. A BASIC gyorsan elterjedt az egyetemeken a time-sharing rendszereken, mivel interaktív tolmácsként működött, azonnali visszajelzést adva a tanulóknak. 1967-ben Norvégiában '''Ole-Johan Dahl és Kristen Nygaard''' kifejlesztették a '''Simula 67''' nyelvet, amit sokan az első ''objektumorientált programozási nyelvnek'' tekintenek. A Simula-ban jelentek meg először az „objektum” és „osztály” fogalmak (igaz, ők még inkább szimulációs kontextusban használták, pl. folyamatok modellezésére), de ez a koncepció később alapja lett számos nyelvnek (Smalltalk, C++ stb.) és a szoftverfejlesztés új paradigmájának. A ''hálózati protokollok'' fejlődésével új szkriptnyelvek is születtek: például 1969-ben a ''BCPL'' nyelvből (egy egyszerű rendszerszintű nyelvből) '''Ken Thompson''' megírta a ''B nyelvet'' a UNIX fejlesztéséhez, majd 1970-ben '''Dennis Ritchie''' továbbfejlesztette ezt ''C nyelvvé'' a Bell Labs-nál. A C nyelv azonban hivatalosan 1972-ben jelent meg, így a ’60-as évek végén még csak formálódott – de meg kell említeni, mert a tervezési folyamat már a UNIX alkotása közben elindult. A fordítóprogramok és egyéb fejlesztői eszközök terén is előrelépés történt. 1962-ben megjelent az első '''fordítófordító''' (compiler-compiler), az IBM ''FLOW-MATIC'' és hasonló eszközök utódaként az ''YACC'' (Yet Another Compiler-Compiler) 1970-ben – ezek célja az volt, hogy megkönnyítsék új nyelvek fordítóinak létrehozását. A ''szimbólikus debug'' eszközök is megjelentek: pl. a '''IBM''' fejlesztette ki az első hibakereső programokat nagygépein, és a felhasználók elkezdték használni a ''„print debugging”'' helyett a memóriatartalom vizsgálatára szolgáló szoftvereket. 1968 egy fontos év volt a szoftverfejlesztés történetében: a NATO konferencián elhangzott '''Edsger Dijkstra''' híres cikke: ''„Go To Statement Considered Harmful”'', amely a goto utasítás túlzott használata ellen érvelt és a struktúrált programozás mellett tette le a voksát. Ugyanebben az évben beszéltek először nyíltan a ''„szoftverválságról”'': arról, hogy a szoftverek komplexitása meghaladja a fejlesztési módszerek képességeit, és új szemléletre van szükség – így született meg a ''szoftverfejlesztés mint mérnöki diszciplína'' (software engineering) gondolata. <span id="alkalmazási-területek-2"></span> === Alkalmazási területek === A ’60-as években a számítógépek behatoltak az élet szinte minden területére, legalábbis a fejlett országokban. A '''tudományos kutatás''' terén a számítógépek nélkülözhetetlenné váltak: a NASA az 1960-as években számítógépeket alkalmazott az ''űrkutatásban'', például a Mercury és Gemini programokban a röppályák számítására, majd az Apollo program során a fedélzeti számítógép (AGC – Apollo Guidance Computer) irányította a holdkompot. Ez utóbbi egy 2 MHz alatti, 2kB RAM-mal rendelkező integrált áramkörös minigép volt, amely kihívások közt is bizonyított, például az Apollo–11 holdraszállásakor, amikor a program újraindult túlterhelés miatt, de a szoftver ''hibatűrő'' kialakítása lehetővé tette a küldetés folytatását. A '''katonai alkalmazások''' közül a stratégiai fegyverrendszerek és korai figyelmeztető rendszerek emelhetők ki: a SAGE rendszer a ’60-as években vált teljesen működőképessé, egy észak-amerikai radarrendszer-hálózatot kötve össze hatalmas ''AN/FSQ-7'' számítógépekkel. Ezek a gépek valós idejű adatokat dolgoztak fel és vadászrepülőket irányítottak – lényegében az első ''online'' hálózati rendszernek tekinthetők. A rakétavédelemben és az űrversenyben a számítógépek szintén kulcsszerepet játszottak. Az '''üzleti életben és kormányzatban''' a ’60-as évek hozta el az ''adatbázis-kezelés'' kezdetét. 1965-ben az IBM létrehozta az első nagyszabású adatbázis-rendszereket például a szociális biztonsági nyilvántartáshoz. 1964-ben indult útjára a '''SABRE''' nevű légifoglalási rendszer az American Airlines és az IBM közös projektjeként – ez a rendszer több várost összekapcsolva valós időben kezelte a repülőjegy-foglalásokat, és úttörő lett az online tranzakciófeldolgozásban. A '''telekommunikációban''' is megjelentek a számítógépek: az 1960-as években a telefonhálózatok kapcsolóközpontjait kezdték el digitalizálni. 1965-ben a Bell Labs kifejlesztette az első ''elektronikus telefonközpontot'' (ESS – Electronic Switching System), amelyben számítógép irányította a híváskapcsolást, javítva a hálózat megbízhatóságát és kapacitását. A '''hálózatok''' terén, ahogy említettük, 1969-ben az ARPANET létrejötte új alkalmazási lehetőségeket nyitott: eleinte a tudományos és katonai intézmények között osztottak meg erőforrásokat (pl. egy-egy különleges nyomtatót vagy számítógépet távolról használtak). 1965-ben '''Donald Davies''' és '''Paul Baran''' egymástól függetlenül leírták a ''csomagkapcsolt hálózatok'' elvét, ami az ARPANET és később az internet alapja lett. 1969-re nem csak az USA-ban, de az Egyesült Királyságban (NPL network) és máshol is kísérleteztek hálózatokkal – sőt, 1973-ban létrejött az első nemzetközi hálózati kapcsolat London és az ARPANET között. A '''szórakoztatóiparban''' is megjelentek az első fecskék: 1962-ben a MIT-n megírták a ''Spacewar!'' nevű számítógépes játékot egy DEC PDP-1 gépen, ami két játékosnak biztosított interaktív élményt – ez a játék a hacker-kultúra egyik legendája lett. Bár kereskedelmi forgalomba nem került, a Spacewar inspirálta később, 1971-ben az első coin-op videojátékot (Computer Space). A ’60-as évek tehát a számítógépes játékok és a digitális szórakoztatás csíráit is hordozta magában. <span id="fontos-idézetek-és-koncepciók-2"></span> === Fontos idézetek és koncepciók === A ’60-as évek elején '''Gordon Moore''', az Intel társalapítója, 1965-ben megfogalmazta a később ''Moore-törvényként'' ismert megfigyelését: miszerint az integrált áramkörökön a tranzisztorok száma (és ezzel a számítógépek teljesítménye) nagyjából kétévente megduplázódik. Ez a „törvény” döbbenetes pontossággal jellemezte a következő évtizedek fejlődését, és a félvezetőipar önbeteljesítő céljává vált. 1968-ban a már említett '''Dijkstra'''-cikk, a ''„Go To statement considered harmful”'', alapvető szemléletváltást indított a programozásban: a struktúrált programozás térnyerése kezdődött, ami a programozási nyelvek és módszerek letisztulásához vezetett. Dijkstra egy másik híres mondata 1968-ból: ''„A szoftverfejlesztés katasztrofális állapotban van”'' – ezzel a szoftverválságra utalt, ami akkor már érzékelhetően fenyegette a nagy projekteket. 1969-ben '''Ken Thompson''' és '''Dennis Ritchie''' a ''„Unix filozófia”'' szellemében alkották meg a UNIX rendszert, melynek része egy máig idézett elv: ''„Készíts egyszerű dolgokat, amelyek jól működnek együtt”''. A UNIX kis, jól körülhatárolt eszközökből állt, amelyeket csővezetékekkel lehetett összefűzni – ez a filozófia a szoftvertervezés tartós koncepciójává vált. A NASA holdraszállása kapcsán '''Gene Kranz''', az irányítóközpont vezetője kijelentette: ''„Failure is not an option”'' („a kudarc nem opció”), ami ugyan emberi vonatkozású mottó, de jól tükrözi azt a megbízhatósági szemléletet, amit a ’60-as években a számítógépektől is elvártak, különösen kritikus alkalmazásokban. Ugyanebben az időben hallhattuk '''John F. Kennedy''' 1961-es beszédét is: ''„Eldöntöttük, hogy még ebben az évtizedben embert juttatunk a Holdra és vissza is hozzuk biztonságban”'' – ez a kihívás a számítástechnika fejlődését is felgyorsította, hiszen az űrprogram rengeteg újítást igényelt a navigáció, vezérlés és számítógép-irányítás terén. <span id="nyílt-problémák-és-versenyek-2"></span> === Nyílt problémák és versenyek === A ’60-as években számos, ma ismerős probléma kezdett körvonalazódni. Az egyik ilyen a '''szoftver méretének és komplexitásának kezelése''' – az évtized végén megfogalmazott szoftverválság lényege, hogy a hagyományos eszközökkel nem lehet könnyen áttekinteni és karbantartani az egyre bonyolultabb programokat. Erre válaszul a struktúrált programozás és később az objektumorientált programozás kínált megoldást, de a kérdés nyitott maradt, hogyan lehet igazán nagy szoftvereket ''„mérnöki alapossággal”'' készíteni. A '''hardver terén''' is volt nyitott kérdés: a ''Miniaturizálás'' határai meddig tolhatók? Moore törvénye ugyan iránymutatást adott, de a mérnökök már a ’60-as években felismerték, hogy előbb-utóbb fizikai korlátokba ütközhetnek. Akkoriban a gond inkább az integrálás megbízhatóságával és a hőelvezetéssel volt, de a következő évtizedekre előre tekintve a kérdés mindig ott lebegett, meddig skálázható a technológia. Az '''ember-gép kapcsolat''' is nyitott kihívást jelentett. 1968. december 9-én '''Douglas Engelbart''' tartott egy híres bemutatót (a „Mother of All Demos”-t), ahol megmutatta az általa kitalált ''egér'' használatát, a grafikus felület csíráit (ablakok), hipertextet és videókonferenciát is. Bár a technológia készen állt, nyitott kérdés volt, hogyan lehetne ezt széles körben elterjeszteni és valóban felhasználóbaráttá tenni a számítógépeket. Az Engelbart által felvetett ötletek megvalósítása és tökéletesítése a ’70-es, ’80-as évek feladata lett (Xerox PARC, majd Apple és Microsoft munkái révén). A '''mesterséges intelligenciában''' is maradtak nyitott problémák: bár a kezdeti optimizmus nagy volt, a határok is megmutatkoztak. 1967-re megjelentek az első ''nyelvfordító'' programok (gépi fordítás), de messze elmaradtak a várt szinttől; a gépi látás és a hangfelismerés pedig még kezdetleges stádiumban volt. Az ''AI versenyek'' közül említést érdemel, hogy 1966-ban az ELIZA program (Joseph Weizenbaum) ugyan elkápráztatta a laikusokat pszichoterapeuta-szimulációjával, de a szakmabeliek látták, hogy a mesterséges intelligencia átment egy túlzott hype-on, amit a források ideiglenes apadása követett (AI-tél a ’70-es években). Verseny szempontjából a '''számítógépes sakk''' egy fontos terület volt: 1967-ben a MacHack VI program megnyerte az első sakkmérkőzést egy amatőr sakkjátékos ellen, és 1970-ben rendezték az első ''Nemzetközi Számítógépsakk-bajnokságot''. Tehát a ’60-as évek végére a számítógépek közötti versengés elkezdődött az AI területén, bár ezek inkább barátságos megmérettetések voltak. A ''programozói versenyek'' is megjelentek egyetemi berkekben: a diákok összevetették BASIC vagy FORTRAN tudásukat, de a formális nemzetközi programozói versenyek (mint az '''ACM ICPC''') csak 1977-ben indultak. Összességében a ’60-as évek végén a számítástechnika hihetetlen távlatokat nyitott, de egyúttal rávilágított a még megoldásra váró nehézségekre – a következő évtizedek ezen problémák közül sokat meg is oldottak. <span id="es-évek-a-mikroprocesszor-és-a-személyi-számítógép-születése"></span> == 1970-es évek – A mikroprocesszor és a személyi számítógép születése == [[File:Intel_C4004.jpg|thumb|Az Intel 4004 mikroprocesszor (1971) – az első kereskedelmi forgalomban kapható egylapkás központi feldolgozóegység, amely 4 biten működött és ~2300 tranzisztort tartalmazott.]] <span id="találmányok-és-első-használatok-3"></span> === Találmányok és első használatok === A 1970-es évek elején a számítástechnika új korszakba lépett a '''mikroprocesszorok''' megjelenésével. 1971. november 15-én az '''Intel''' piacra dobta a ''4004'' jelű mikroprocesszort, a világ első egyetlen chipre integrált CPU-ját. A 4004 csupán 4 bites adatszélességű volt és nagyjából 2300 tranzisztort tartalmazott, de képes volt másodpercenként ~60 000 művelet végrehajtására. Hamarosan követték erősebb testvérei: 1972-ben az ''Intel 8008'' (8 bites), 1974-ben az ''Intel 8080'', ami már ~0,5 MIPS teljesítményű, általános célú processzor volt. Ezek a mikroprocesszorok alapozták meg a személyi számítógépek létrejöttét. 1973-ban '''Robert Metcalfe''' és csapata a Xerox PARC-ban megalkotta az ''Ethernet'' technológiát, amely olcsó kábelek segítségével tette lehetővé számítógépek helyi hálózatba kötését. Az Ethernet hamar szabvánnyá vált és a későbbi lokális hálózatok (LAN-ok) gerincévé nőtte ki magát – ez is a ’70-es évek újítása. Ugyancsak 1973-ban '''Vinton Cerf és Robert Kahn''' elkezdték kidolgozni a ''Transmission Control Protocol'' (TCP) elődjét, ami az internethálózatok összekapcsolását tette lehetővé, megszületett az „internet protokollok” alapja. A tárolás terén is voltak jelentős újdonságok: 1971-ben az IBM bevezette az ''8 hüvelykes floppy lemezt'' adatcserére. Ez a hajlékony mágneslemez új, kényelmes módját kínálta a programok és adatok tárolásának és terjesztésének. 1979-ben megjelent a ''kompaktlemez (CD)'' prototípusa is – a Philips és a Sony kifejlesztette a digitális optikai adattárolás technológiáját, igaz a kereskedelmi CD csak 1982-ben debütált audió formátumban. A ’70-es évek közepén megszületett a '''személyi számítógép''' fogalma. 1975 januárjában a Popular Electronics magazin címlapján bemutatkozott a ''MITS Altair 8800'' számítógép, amely egy otthoni építésű készlet formájában volt kapható, és az Intel 8080 mikroprocesszoron alapult. Az Altair 8800 hatalmas siker lett a hobbyisták körében, és több ezer darabot adtak el belőle – sokan ezt tekintik az első PC-nek. Az Altair sikerén felbuzdulva 1975-ben '''Bill Gates''' és '''Paul Allen''' megírták az Altair BASIC tolmácsot, majd megalapították a '''Microsoftot''' a mikroszámítógépes szoftverek fejlesztésére. 1976-ban '''Steve Jobs és Steve Wozniak''' elkészítették az ''Apple I'' számítógépet (majd 1977-ben az Apple II-t), amely már készen összeszerelt formában, billentyűzettel és monitorral együtt kínált egy könnyebben használható személyi gépet. 1977 a személyi számítástechnika „szentháromságának” éve lett: piacra került az ''Apple II'', a ''Commodore PET'' és a ''Radio Shack TRS-80'' – három egymással versengő, de egyaránt népszerű személyi számítógép, melyek megalapozták az otthoni és irodai számítógép-forradalmat. <span id="hardverrendszerek-és-processzorok-3"></span> === Hardverrendszerek és processzorok === A mikroprocesszorok forradalma alapjaiban változtatta meg a számítógépek hardverfelépítését. Az 1970-es években sorra jelentek meg az új processzorok: az '''Intel 8080''' (1974) és ennek versenytársai, a '''Motorola 6800''' (1974) és a '''MOS Technology 6502''' (1975). A MOS 6502 különösen nagy hatású lett, mivel mindössze $25-ba került, így beépítették számos korai személyi számítógépbe (Apple II, Commodore PET, Atari konzolok stb.). A 8 bites processzorok generációja a ’70-es évek végére ért csúcsra: 1978-ban az Intel kiadta az ''8086'' processzort (16 bites belső felépítéssel, de 1979-ben piacra dobták 8 bites buszú változatát, az ''8088''-at is). Az Intel 8086/8088 processzorra épült később az IBM PC, de erről bővebben a ’80-as években. 1979-ben a Motorola is bemutatta a ''68000''-es processzort (16/32 bites architektúra), amely a következő években az Apple Macintosh és sok más gép motorja lett. A '''szuperszámítógépek''' terén is folytatódott a verseny. 1976-ban '''Seymour Cray''' megépítette a ''Cray-1'' vektorszámítógépet, amely 80 MFLOPS teljesítményével a világ leggyorsabb gépe lett. A Cray-1 innovatív, ''vektorprocesszoros'' kialakítást alkalmazott, mely lehetővé tette, hogy egy utasítással egész vektorsorozatokat dolgozzon fel – ezzel ideális volt tudományos szimulációkhoz (pl. időjárás-előrejelzés, aerodinamikai számítások). A Cray-1 elegáns, C-alakú formaterve és hűtőpadként funkcionáló „ülőkéje” ikonikus megjelenést kölcsönzött a szuperszámítógépek új generációjának. A memória és háttértár kapacitás robbanásszerűen nőtt: a ''félvezető memóriák'' (RAM chipek) kiszorították a ferritmag-tárakat. 1970-ben az Intel bemutatta az első DRAM chipet, az 1103-at, amely 1 kilobit tárolására volt képes. Ez aprónak tűnik, de ezekből a chipekből modulokat építve néhány kilobájt már megbízhatóan rendelkezésre állt a mikro- és miniszámítógépekben. A merevlemezek is egyre elterjedtebbek lettek: az 1970-es évek közepén egy tipikus miniszámítógép már ''Winchester'' merevlemezzel (néhány tíz megabájtos kapacitással) érkezett. 1979-ben a '''Seagate''' kihozta az első 5,25 hüvelykes winchester merevlemezt PC-khez (5 MB kapacitással), megalapozva a PC-k belső merevlemezeit. A ''számítógépes architektúrák'' terén a ’70-es évek végére kibontakozott a '''RISC''' (Reduced Instruction Set Computer) filozófia csírája. 1975-ben az IBM 801 prototípussal és a később induló Berkeley RISC projekttel kezdték vizsgálni, hogy egy egyszerűsített utasításkészletű processzor magas órajelen hatékonyabban működhet. Bár a RISC processzorok tömegpiaci megjelenése a ’80-as évekre esik, a koncepció alapjai már a ’70-es években formálódtak. <span id="operációs-rendszerek-3"></span> === Operációs rendszerek === A 1970-es években az operációs rendszerek a mainframe-ektől a személyi gépekig minden szintén jelen voltak. Az IBM nagygépein futó '''OS/360''' továbbfejlődött (megjött a virtuális memóriát támogató változat, az OS/VS), ezzel párhuzamosan megjelentek a gyártó-specifikus mainframe OS-ek (pl. DEC TOPS-10 a PDP-10 gépeken, ICL VME az ICL mainframe-eken stb.). A miniszámítógépek világában a '''Digital Equipment Corporation''' kifejlesztette a ''RT-11'' és ''RSTS/E'' rendszereket a PDP gépcsaládhoz, illetve 1977-ben a ''VMS'' operációs rendszert a VAX gépeihez. A VMS (Virtual Memory System) egy 32 bites virtuális memóriás, időosztásos OS volt, kifejezetten a nagyteljesítményű mini- és szuperszámítógépek igényeire szabva. Talán az évtized legfontosabb operációs rendszer eseménye a '''UNIX térhódítása'''. A ’70-es évek elején a Bell Labs UNIX rendszere elterjedt a tudományos intézményekben, különösen miután 1973-ban a UNIX-ot C nyelven újraírták, és az AT&amp;T kedvezményes licenc alatt hozzáférhetővé tette egyetemeknek. 1975-re számos egyetem futtatott UNIX-ot PDP-11 gépeken, és kialakult a UNIX közösség. A UNIX egyszerűsége és hordozhatósága (köszönhetően a C nyelvnek) előrevetítette, hogy a különböző számítógéptípusokon is egységes operációs rendszer futhat – ez akkoriban forradalmi gondolat volt a sok gyártó-specifikus OS mellett. 1978-ra a UNIX már eljutott a Version 7-hez, amely tartalmazta a pipe-okat, sok mai parancs elődjét és az első hálózati kommunikációs eszközöket (UUCP). A '''személyi számítógépek''' megjelenése új operációs rendszereket hívott életre. 1977-ben a Commodore, az Apple és a Tandy gépei még jellemzően beépített BASIC interpreterrel indultak és kazettáról vagy lemezről betöltött alkalmazásokat futtattak, de hamar igény lett valamilyen lemezkezelő rendszerre. 1976-ban '''Gary Kildall''' megírta a ''CP/M'' operációs rendszert a 8 bites mikrokomputerekhez. A CP/M egyszerű parancssoros OS volt, amely lemezfájlrendszert és alapszintű programbetöltést biztosított a Z80 és 8080 alapú gépek számára. A ’70-es évek végére a CP/M vált a de-facto szabvánnyá a mikrogépek között – számtalan szoftver készült rá, és ezt tekinthetjük az MS-DOS elődjének is. A grafikus felhasználói felület gondolata is megszületett a ’70-es években, bár még nem vált kereskedelmi valósággá. A '''Xerox PARC''' kifejlesztette a ''Alto'' számítógépet 1973-ban, amelyen egy primitív grafikus operációs környezet futott (ikonokkal, ablakokkal és egér támogatással). Az Alto sosem került piacra, de 1979-ben az Apple meglátogatta a PARC-ot és inspirációt merített a grafikus interfészből – ebből született meg majd az Apple Lisa (1983) és a Macintosh (1984) operációs rendszere. Így bár a ’70-es években a hétköznapi felhasználó még nem találkozott grafikus operációs rendszerrel, a laborokban és kutatóközpontokban már létezett ez a koncepció. <span id="programozási-nyelvek-és-fejlesztői-eszközök-3"></span> === Programozási nyelvek és fejlesztői eszközök === Az 1970-es évek folyamán tovább bővült a programozási nyelvek palettája. 1970-ben '''Niklaus Wirth''' publikálta a '''Pascal''' nyelvet, amely az ALGOL örökségét vitte tovább egyszerűbb és tanulhatóbb formában, kifejezetten az oktatás és a struktúrált programozás igényeire szabva. A Pascal rövidesen népszerű lett az egyetemeken, majd a ’80-as évek PC-s környezetében is (Turbo Pascal formájában). 1972-ben megszületett a '''C nyelv''' ('''Dennis Ritchie'''), amelyet eredetileg a UNIX rendszer implementálására terveztek a Bell Labs-nál. A C hordozhatósága és hatékonysága miatt gyorsan terjedni kezdett a különféle platformokon, és a ’70-es évek végére számos szoftver (nem csak UNIX) készült már C-ben. A C nyelv bevezette a mai alacsony szintű, de mégis magas szintű nyelvek (közvetlen memóriacímzés, mutatók, strukturált típusok) alapvető eszköztárát, és hatása szinte minden későbbi nyelvben tetten érhető. 1972 egy másik jelentős nyelv születését is látta: '''Prolog''' (Franciaországban '''Alain Colmerauer''' és kollégái). A Prolog a ''logikai programozás'' nyelve, elsősorban mesterséges intelligencia, szakértői rendszerek terén használták. Újszerű volt, hogy deklaratív módon, szabályok és tények formájában kellett benne a problémát megfogalmazni, és a megoldást a logikai következtető motor kereste meg – ez teljesen más paradigmát jelentett a hagyományos imperatív nyelvekhez képest. 1975 körül a '''strukturált programozás''' és a szoftverfejlesztés módszertanai kezdtek beérni. Ekkor jelentek meg az első ''moduláris programozás'' támogatására szolgáló nyelvek, mint például a '''Modula''' (Wirth, 1977) vagy az '''Ada''' (amit az amerikai Védelmi Minisztérium megbízásából 1979-ben kezdtek fejleszteni '''Jean Ichbiah''' vezetésével, és 1983-ra készült el). Az Ada nyelv kifejlesztését éppen a ’70-es évek végén felismert szoftverválság motiválta: egy olyan egyesített, erős típusellenőrzésű nyelvet akartak, amely a nagy katonai szoftverprojektekben használható. 1979-ben be is jelentették az Ada első verzióját. A '''fejlesztői eszközök''' terén a ’70-es évek újdonságai közé tartozott a verziókezelés és a debug technikák fejlődése. 1972-ben az '''Bell Labs''' kifejlesztette az első széles körben használt verziókövető rendszert, a ''SCCS''-t (Source Code Control System), hogy nagy szoftverprojektek forráskódját kezelni tudják verziók és párhuzamos fejlesztések mentén. A ''make'' eszköz 1976-ban jelent meg a UNIX világban (Stuart Feldman), automatizálva a szoftverfordítás lépéseit. A ’70-es évek végére a programozók rendelkezésére álltak a modern fordítóprogramok (a C compiler, Pascal compiler stb.), linkerek, és egyre jobb szövegszerkesztők (a Unix ''vi'' editor 1976-ban készült el, a ''Emacs'' szövegszerkesztő első verziója pedig 1976-ban jelent meg '''Richard Stallman''' jóvoltából). A ’70-es években a '''szoftverfejlesztés''' kezdett ipari méreteket ölteni, és ezzel együtt megjelentek az első integrált fejlesztői környezetek (IDE-k) csírái is. Például a UCSD Pascal rendszer (1978) egy komplett fejlesztői környezetet biztosított Pascal nyelvhez, saját operációs rendszerrel, virtuális géppel (P-code) – előrevetítve a Java VM elvét. <span id="alkalmazási-területek-3"></span> === Alkalmazási területek === Az 1970-es évekre a számítógépek '''meghódították az ipart, az irodákat és az otthonokat''' is (legalábbis az évtized végére). A '''nagyvállalati informatikában''' standarddá váltak a relációs adatbázis-kezelők, amelyek elméleti alapjait '''E. F. Codd''' fektette le 1970-ben. A ’70-es évek második felében az IBM és más cégek kifejlesztették az első relációs adatbázis-kezelő prototípusokat (System R, Ingres), és 1979-ben a '''Oracle''' kiadta az első kereskedelmi relációs adatbázis-kezelőt. Ez forradalmasította az üzleti adatok tárolását és lekérdezését, az SQL nyelv szabvánnyá vált. Az '''irodai alkalmazások''' az évtized végén születtek meg a személyi számítógépeken. 1978-ban jelent meg az első elektronikus táblázatkezelő program, a ''VisiCalc'', Apple II gépeken futott és sokak szerint ez volt az első „gyilkos alkalmazás” (killer app), amely miatt emberek tömegesen vásároltak személyi számítógépet. A VisiCalc lehetővé tette pénzügyi tervek, költségvetések interaktív kalkulációját, amivel forradalmasította a könyvelést. Hasonló áttörés volt a szövegszerkesztés: bár kezdetben a számítógépes szövegszerkesztés inkább nagygépeken történt (pl. a UNIX ''roff/nroff'' programjaival), 1979-ben megjelent a MicroPro '''WordStar''' CP/M gépekre, ami az első széles körben használt PC-s szövegszerkesztő lett. A '''mérnöki tervezésben''' (CAD – Computer-Aided Design) is megjelentek a számítógépek: az 1970-es évek közepén az autó- és repülőgépipar elkezdte használni a grafikus munkaállomásokat (pl. az IBM és a Dassault Systèmes által fejlesztett CATIA elődjei) a tervrajzok digitalizálására és szerkesztésére. A '''tudományos számítások''' területén a szuperszámítógépek egyre nehezebb feladatokat oldottak meg: meteorológiai modellek, molekuláris dinamika szimulációk és nukleáris fegyver-szimulációk futottak a Cray-1 és az azt követő gépeken. 1979-ben a Los Alamos laborban felállították az első Cray-1 gépet, ami lehetővé tette addig elképzelhetetlen részletességű számítások végzését. A '''hálózatépítés''' is felgyorsult: 1977-re az ARPANET hálózat már átszelte az Egyesült Államokat, és csatlakozott hozzá néhány európai csomópont is. 1978-ra az e-mail vált az ARPANET „gyilkos alkalmazásává” – a felhasználók többsége a levelezést használta leggyakrabban. Az elektronikus levelezés feltalálása '''Ray Tomlinson''' nevéhez fűződik, aki 1971-ben küldött először e-mailt két ARPANET gép között, és ő vezette be a ''@* szimbólumot is az e-mail címekben. A ’70-es évek végére már listák és hírlevél-szerű csoportos e-mailek is léteztek, sőt 1979-ben '''Tom Truscott és Jim Ellis''' létrehozták a ''Usenet* hírcsoport rendszert, amely az internet előtti fórumok, közösségi terek prototípusának tekinthető. A '''szórakoztató elektronika''' robbanása is erre az időre tehető. 1972-ben megjelent a ''Pong'' videojáték arcade változata, megalapítva a videojáték-ipart. 1977-ben debütált az '''Atari 2600''' játékkonzol a MOS 6502 leszármazottját tartalmazó CPU-val – ez a konzol tette otthoni hobbivá a videojátékot. 1978-ban a japán ''Space Invaders'' videojáték által kiváltott „játékgép-őrület” mutatta, hogy a számítógépek új területe a szórakoztatás lett. A számítógépes játékok a PC-kre is megérkeztek: 1978-ban jelent meg az ''Adventure'' (Colossal Cave) szöveges kalandjáték PDP-10-re, és 1979-ben az ''Aknafedő'' (Microsoft Adventure) PC-re, majd 1980-ban a Rogue – mind a későbbi játékstílusok előfutárai. <span id="fontos-idézetek-és-koncepciók-3"></span> === Fontos idézetek és koncepciók === A ’70-es évek számos emlékezetes mondást és koncepciót adott a számítástechnika történetéhez. 1975-ben a ''Homebrew Computer Club'' egyik levelében '''Bill Gates''' nyílt levélben ostorozta a hobbi programozókat azzal a felütéssel, hogy ''„nyílt levél a hobbistákhoz”'' – ebben sérelmezte, hogy az Altair BASIC értékes programját sokan fizetség nélkül másolják, és ezzel a szoftverfejlesztők megélhetését veszélyeztetik. Ez a levél a '''szoftver tulajdonjog''' viták korai dokumentuma, és előrevetítette a későbbi szoftverlicencelési modellek fontosságát. 1977-ben '''Ken Olsen''', a DEC alapítója hírhedten kijelentette: ''„Nincs semmi ok, amiért bárki is akarna számítógépet az otthonában”''. Ezt a korabeli gondolkodást jól tükröző idézetet később sokat emlegették téves jövőbelátás példájaként, hiszen pár éven belül a személyi számítógépek robbanásszerűen terjedni kezdtek. Olsen valójában a ’70-es évek végének helyzetére utalt, amikor a PC-k még kezdetlegesek voltak és kevés gyakorlati hasznot hoztak egy átlagember számára – de a technológia gyorsan rácáfolt a szavaira. '''Grace Hopper''' egy másik, humorosabb kontextusú idézete is erre az időszakra esik: gyakran mutogatta a 30 centiméter hosszú vezetéket, mondván ''„ez itt egy nanosec”'', utalva arra, hogy a fény vagy az elektromos jel kb. 30 cm-t tesz meg egy nanomásodperc alatt. Ezzel érzékeltette a fiatal programozóknak a számítógép belső sebességét és a késleltetések jelentőségét. A '''„gyilkos alkalmazás” (killer app)''' fogalma szintén a ’70-es évek végén született meg, amikor a VisiCalc kapcsán használták először: arra utalva, hogy egyetlen alkalmazás (jelen esetben a táblázatkezelő) képes egész platformok sikerét meghatározni, mert a felhasználók csak emiatt megveszik a szükséges hardvert. Ez a koncepció később is gyakran előjött (pl. a ’80-as években a desktop publishing a Macintosh esetében). <span id="nyílt-problémák-és-versenyek-3"></span> === Nyílt problémák és versenyek === A 1970-es években a technológiai fejlődés felvetett néhány új nyílt problémát is. Az egyik ilyen a '''kompatibilitás''' és '''szabványosítás''' kérdése. Ahogy egyre több cég gyártott mikroprocesszorokat, perifériákat és írt operációs rendszereket, fennállt a veszélye, hogy ezek egymással nem lesznek kompatibilisek. A ’70-es évek végén indult meg a szabványosítási törekvés: 1977-ben létrejött az '''IEEE''' számára a ''POSIX'' szabvány kezdeménye (bár hivatalosan csak ’80-as években standardizálták), a mikroszámítógépek világában pedig az '''S-100 busz''' (az Altair busza) és a CP/M operációs rendszer de-facto szabvánnyá vált a kompatibilitás érdekében. De kérdéses volt, hogy meddig tartható fenn az a helyzet, hogy szinte minden cég saját platformot épít – ez a nyílt probléma a ’80-as évekre a ''„platformháborúk”'' formáját öltötte (pl. PC vs. Apple vs. Commodore). A '''szellemi tulajdon és szoftverlicencelés''' is nyitott kérdés volt. Gates említett levele rávilágított arra, hogy a szoftvereket addig hajlamosak voltak az emberek ingyenes mellékterméknek tekinteni, míg a fejlesztők már komoly munkát fektettek beléjük. Ez a probléma a ’80-as években éleződött ki jogi viták formájában (pl. IBM PC BIOS klónok, Microsoft vs. Apple „look-and-feel” per). A ’70-es évek végére ugyanakkor egy ellentétes mozgalom csírája is megjelent: '''Richard Stallman''' 1976-77 körül kezdett elégedetlen lenni a szoftverek egyre zártabbá válásával és 1983-ban elindította a ''GNU Projektet'', de ennek előzményei a ’70-es évek közepére vezethetők vissza (pl. amikor a MIT AI lab nyomtatója szoftveréhez nem kapott forráskódot, Stallman elvi ügyet csinált belőle). Tehát a nyílt forráskódú szoftver és a proprietáris szoftver ellentéte már felütötte fejét, bár igazi versengéssé a ’80-as években vált. A '''versenyek''' terén a ’70-es évek két fontos vonulatot hoztak: a programozói és mesterséges intelligencia versenyeket, valamint a kereskedelmi piaci versenyt. 1970-ben tartották az első ACM által szervezett számítógépes sakkbajnokságot New Yorkban – ez az esemény a számítógépek közti versengés egyik első formális megnyilvánulása. 1974-ben aztán az első ''Világ Számítógépsakk Bajnokságot'' is megrendezték Stockholmban, ami azt mutatja, hogy a nemzetek (és vállalatok) már akkor is presztízskérdést csináltak az AI ezen ágából. A ’70-es évek végén, 1977-ben elindult az '''ACM Nemzetközi Programozóversenye (ICPC)''' is, kezdetben egyetemi csapatok számára, bár igazán nagy nemzetközi eseménnyé a ’80-as évekre nőtte ki magát. A kereskedelmi versenyben az '''IBM vs. a „közösség”''' jelentett sajátos nyílt kérdést. Az IBM mainframe-ek dominanciáját sokan meg akarták törni: 1975-ben az ''IBM antitröszt per'' még zajlott (1969-ben indították az USA-ban és csak ’82-ben zárult le). Közben a személyi számítógép piacon új szereplők bukkantak fel és kérdés volt, ki nyeri a ''„PC-háborúkat”''. A ’70-es évek végén még nyitott volt, hogy a Tandy/Apple/Commodore hármasból ki kerül ki győztesen – végül egyikük sem közvetlenül, hanem az IBM 1981-es belépése és a nyílt PC platform lett a meghatározó. De 1979-ben ezt még nem lehetett látni; Steve Jobs pl. egy 1979-es interjúban azt mondta: ''„Az IBM nem tudja megcsinálni, amit mi”'', utalva arra, hogy úgy vélte, az IBM túl merev a személyi számítógép piac gyors innovációihoz – ami részben igaz is volt, de az IBM mégis nyerni tudott a nyílt architektúra stratégiájával. Összegzésképpen a ’70-es évek a számítástechnika történetében az innováció és az új lehetőségek évtizede volt. A mikroprocesszor és a PC megjelent, az internet csírái kifejlődtek, a szoftveripar pedig önálló lábra állt. A nyílt problémák és versenyek a technológia további fejlődésének irányát is kijelölték, így előkészítve a terepet a robbanásszerű ’80-as éveknek. <span id="as-évek-személyi-számítógép-forradalom-és-az-internet-hajnala"></span> == 1980-as évek – Személyi számítógép-forradalom és az internet hajnala == <span id="találmányok-és-első-használatok-4"></span> === Találmányok és első használatok === Az 1980-as években a '''számítógépek tömegcikké váltak'''. 1981. augusztus 12-én az IBM bemutatta az ''IBM PC''-t (IBM 5150), egy nyílt architektúrájú személyi számítógépet, melynek tervét részben más cégek alkatrészeire építette. Az IBM PC hatalmas siker lett: már a megjelenés évében 100 000 rendelést vettek fel rá, és az IBM által teremtett platform (az Intel 8088 processzor és a Microsoft PC DOS operációs rendszer kombinációja) gyorsan ipari szabvánnyá vált. Mivel az IBM PC architektúrája „nyílt” volt (a buszok és interfészek dokumentáltak, az alkatrészek beszerezhetők), hamar megjelentek az ''IBM PC kompatibilis'' klónok is olyan gyártóktól, mint a Compaq, Dell, AST stb. Ez a nyílt megközelítés biztosította a PC hosszú távú dominanciáját. 1984 januárjában az '''Apple''' bemutatta a ''Macintosh'' számítógépet, amely az első széles körben elterjedt '''grafikus felhasználói felületű (GUI)''' számítógép lett. A Macintosh egérrel vezérelt ablakaival, ikonjaival és menüivel forradalmasította a felhasználói élményt. Bár nem ez volt az első GUI-s gép (előzte az Apple Lisa 1983-ban és a Xerox Alto kísérleti jelleggel), a Mac volt az, amelyet kereskedelmileg sikeresen árusítottak, viszonylag megfizethető $2500 körüli áron. Az 1984-es híres Macintosh reklám („1984”) a személyi számítógép mint a kreativitás eszköze szimbólumává vált. A Mac-hez alapcsomagként érkezett a MacPaint grafikus program és a MacWrite szövegszerkesztő, demonstrálva a WYSIWYG szerkesztés (amit látsz, azt kapod) előnyeit a grafikus környezetben. A játékipar és otthoni számítógépek terén is fontos találmányok születtek: 1983-ban a '''Nintendo''' kiadta Famicom játékkonzolját Japánban (ami 1985-ben NES néven Amerikában is megjelent), új életet lehelve a videójáték-piacba az 1983-as videojáték-ipari válság után. A ''8-bites mikrogépek'' (C64, ZX Spectrum, Apple II stb.) korszaka az évtized közepéig tartott, majd átadta helyét a ''16-bites otthoni számítógépeknek'': 1985-ben került piacra a '''Commodore Amiga 1000''' és az '''Atari ST''', melyek fejlett multimédiás képességeik (színpompás grafika, többcsatornás hang) révén népszerűek lettek az otthoni felhasználók és a játékosok körében. Az Amiga különösen úttörő volt: grafikus operációs rendszere multitaskingra volt képes és olyan programokat futtatott, amelyekkel a felhasználók zenét szerezhettek, videót digitalizálhattak (pl. NewTek Video Toaster, bár ez utóbbi a ’90-es évek elején), és persze kiváló játékplatform is volt. <span id="hardverrendszerek-és-processzorok-4"></span> === Hardverrendszerek és processzorok === Az évtized elején a meghatározó processzorok a 8 és 16 bites architektúrák voltak. Az '''Intel 8086/8088''' (16 bites belső – 8 bites külső buszú változattal) dominált a PC-knél, de 1982-ben megjelent az '''Intel 80286''' (286) processzor, amely már 24 bites címbusszal 16 MB memóriát is megcímezhetett, és védett módot vezetett be, megalapozva a többfeladatos operációs rendszerek PC-s jövőjét. Az IBM AT gépben (1984) már 80286-os CPU volt, kihasználva e teljesítménytöbbletet. 1985-ben jött az '''Intel 80386''' – egy valódi 32 bites processzor, amely óriási előrelépést jelentett: 4 GB címzési tartomány, beépített memóriavédelmi mechanizmusok és viszonylag magas (16-33 MHz) órajelek. A 80386 lehetővé tette a „nagy” operációs rendszerek futtatását PC-n (pl. UNIX variánsok), és 1986-ban a Compaq már piacra dobta az első 386-os PC-t (megelőzve az IBM-et). Ez mutatja, hogy a PC-platformon belül is éles verseny zajlott a gyártók közt. Az évtized végén, 1989-ben megjelent az '''Intel 80486''' processzor, integrált matematikai társprocesszorral és ~1,2 millió tranzisztorral, mely 25 MHz-en ~20 MIPS teljesítményt nyújtott. A 486 már olyan integrációs szintet képviselt, hogy alaplapra forrasztva komplett PC-k „agya” lehetett, külön lebegőpontos koprocesszor nélkül. A rivális CPU-k közül a '''Motorola 68000''' család a Macintoshokban és sok munkaállomásban (pl. Sun-3) hódított. 1984-ben a Motorola bemutatta a ''68020''-at (32 bites, 20 MHz), 1987-ben a ''68030''-at (25 MHz, integrált MMU) és 1989-ben a ''68040''-et (ami már integrált FPU-val is rendelkezett, és 33 MHz-en ~4,5 MIPS-re volt képes). Ezek a CISC architektúrák versengtek az Intel x86 vonalával a számítógépekben – a Macintosh II 1987-ben 68020-ra épült, a Macintosh IIfx 1990-ben pedig 40 MHz-es 68030-ra. A ''RISC forradalom'' is beindult: 1986-ban a '''HP''' kihozta az első saját RISC processzorait (PA-RISC), 1987-ben a '''Sun Microsystems''' a SPARC architektúrát, 1989-ben az '''MIPS''' a R3000-es processzort. Ezek a RISC CPU-k kevesebb tranzisztorral magas órajeleket és hatékony számítási teljesítményt értek el a munkaállomások és szuperszámítógépek terén. Bár a PC-k világában a RISC csak a ’90-es években (PowerPC, DEC Alpha) bukkant fel, az évtized végére már látható volt, hogy a RISC architektúrák kihívást intézhetnek a CISC (x86, 68k) dominancia ellen. A '''tárkapacitások''' is rohamosan nőttek: a memóriamodulokban a ’80-as évek eleji tipikus PC még 64-256 kB RAM-mal jött, de a 640 kB (''„640K ought to be enough”'' – híresen Bill Gates-nek tulajdonított mondás) határt hamar kinőtték, és a késő ’80-as évek AT számítógépeiben már 1-4 MB RAM sem volt ritka. A merevlemezek kapacitása megugrott: az évtized elején egy PC winchester 10 MB körüli volt, 1985-re 20-40 MB, 1989-re pedig megjelentek az 100-200 MB-os meghajtók is az asztali gépekben. 1984-ben az IBM bemutatta az első ''1 gigabájtos'' lemeztárat, igaz ez még egy hűtőszekrény méretű eszköz volt. Az optikai tárolás is valósággá vált: 1982-ben piacra került az Audio CD, majd 1985-ben a CD-ROM (650 MB tárhellyel), noha a CD-ROM meghajtók csak a ’90-es években terjedtek el a PC-kben (az első PC-s CD-ROM meghajtók 1988 körül jelentek meg). A '''perifériák''' terén a ’80-as évek egyebek mellett a lézeres nyomtatást hozta el: az '''HP''' 1984-ben mutatta be az első ''LaserJet'' nyomtatót, ami a később irodai standarddá vált gyors és minőségi nyomtatást tette lehetővé. A '''grafikus megjelenítés''' is hatalmasat lépett: 1981-ben az IBM CGA (színes grafikus adapter) 4 színt tudott egyszerre, 320×200 felbontásban. 1984-ben jött az EGA (16 szín, 640×350), majd 1987-ben a VGA (256 szín, 640×480, sőt emlékezetes 320×200-as módban 256 színű „MCGA”). 1989-ben pedig a VESA (Video Electronics Standards Association) megalakult és megalkotta a VESA BIOS kiterjesztést a grafikus kártyák egységes kezelésére. A PC-s grafika fejlődése megalapozta a későbbi gazdag multimédiát. <span id="operációs-rendszerek-4"></span> === Operációs rendszerek === Az 1980-as évek a '''személyi számítógépek operációs rendszereinek''' berobbanását hozták. Az IBM PC 1981-ben a ''PC DOS 1.0''-val érkezett (amit a Microsoft szállított MS-DOS néven más klónokra is). Az MS-DOS a ’80-as évek első felében a PC-k meghatározó OS-e lett: parancssoros, egyfelhasználós, egyszerre csak egy programot futtató rendszer volt, de a hardver egyszerűsége miatt gyors és folyamatosan fejlődött. 1983 márciusában kijött az ''MS-DOS 2.0'', amely már al-mappákat (könyvtárakat) is támogatott a fájlrendszerben. Az MS-DOS uralma egészen 1995-ig tartott a fogyasztói PC-ken, bár idővel grafikus felülettel kombinálták. A grafikus felületek a PC világban is megjelentek: 1985 novemberében a '''Microsoft kiadta a Windows 1.0'''-t, ami az MS-DOS-ra épülő grafikus héj volt (korlátozott multitaskinggal, ikonokkal, ablakokkal). Bár a Windows 1.0 és a 1987-es 2.0 még nem volt átütő siker, megalapozta a Microsoft későbbi grafikus rendszereit. Az Apple Macintosh viszont már 1984-től komoly GUI-s operációs rendszerrel rendelkezett (System 1.0, majd System 6-ig jutott a ’80-as évek végén), amely könnyű használatával és grafikus képességeivel népszerű volt a desktop kiadványszerkesztésben. ''„Look and feel” per'' zajlott az Apple és Microsoft között, mivel az Apple úgy vélte, a Windows 2.0 túlzottan lemásolta a Mac felületét – a jogvita végül 1997-ig húzódott és peren kívüli megegyezés lett belőle, amikor az Apple ejtette a vádat. A '''hálózati operációs rendszerek''' is megjelentek: 1983-ban a '''Novell''' kiadta a ''NetWare'' rendszerét, amely PC alapú szervereken futva lehetővé tette fájl- és nyomtatómegosztást helyi hálózatokon. A Novell NetWare a ’80-as évek második felében de-facto szabvánnyá vált a PC hálózatokban. A '''UNIX''' szintén hódított: a ’80-as évek elején megjelentek az első kereskedelmi UNIX verziók (Xenix – a Microsoft saját UNIX-a 1980-ban, majd a AT&amp;T UNIX System V 1983-ban). Az AT&amp;T feloldotta a korábbi licenckötöttségeket, így a UNIX a vállalati miniszámítógépektől a mainframe-eken át a munkaállomásokig mindenhová beférkőzött. 1982-ben a '''Sun Microsystems''' megalakulásakor a UNIX-ot választotta munkaállomásain (SunOS/BSD variáns), 1983-ban az AT&amp;T UNIX System V kiadása egységesíteni próbálta a különböző UNIX ágazatokat. A ’80-as évek végére azonban már UNIX „háború” bontakozott ki a különböző gyártói verziók között (Xenix, SCO, SunOS, HP-UX, AIX, etc.), míg másik oldalon a közösség 1983-ban elindította a ''GNU projektet'', egy szabad UNIX-klón megalkotására. 1985-ben megalakult a '''Free Software Foundation''' Stallman vezetésével, ami a szabad operációs rendszer és szoftverek fejlesztését koordinálta – a ’80-as években a GNU sok eszközt (fordítókat, szerkesztőket) készített el, de a kernel hiányzott; ennek megoldására 1991-ig kellett várni (Linux megjelenése). A '''szuperszámítógépek és mainframe-ek operációs rendszerei''' is fejlődtek: az IBM 1988-ban mutatta be az MVS utódját, a ''ESA/370'' architektúrát futtató ''MVS/ESA''-t mainframe-jein; a Cray szuperszámítógépek saját COS operációs rendszert futtattak, majd Unicos néven UNIX-alapú rendszert. A felhő-előd ''„hálózat, mint számítógép”'' koncepció pedig 1984-ben kapott hangot '''John Gage''' (Sun) híres mondásában: ''„The network is the computer.”'' – utalva arra, hogy a SUN gépek hálózatba kötve egy nagy erőforrásként működhetnek. <span id="programozási-nyelvek-és-fejlesztői-eszközök-4"></span> === Programozási nyelvek és fejlesztői eszközök === Az ’80-as években a programozási nyelvek terén a '''struktúrált, moduláris és objektumorientált''' szemlélet erősödött meg. 1983-ban jelent meg hivatalosan az '''Ada''' nyelv első verziója (Ada 83), amelyet a védelmi iparban és repülésben kezdtek alkalmazni biztonságkritikus szoftverekhez. 1985-ben '''Bjarne Stroustrup''' publikálta a '''C++ nyelv''' első hivatalos kiadását (a „C with Classes” kísérleti nyelvből kinőve). A C++ a C nyelv hatékonyságát ötvözte az objektumorientált programozás lehetőségeivel, így hamar népszerű lett a kereskedelmi szoftverfejlesztésben. A ’80-as évek végére a C++ már számos platformon elérhető volt, és kezdte felváltani a klasszikus C-t nagy szoftverprojektekben. A '''funkcionális programozás''' is kapott egy lökést: 1984-ben megjelent a '''Miranda''' nyelv az egyetemeken (David Turner), ami a későbbi Haskell nyelv előfutára volt. Bár a funkcionális nyelvek (Lisp, ML, Scheme, Miranda) inkább akadémiai körökben maradtak, hatásuk a nyelvelméletre és később a gyakorlati nyelvekre is (lambda kifejezések, magasabbrendű függvények) tetten érhető. A '''BASIC''' nyelv továbbfejlődött az otthoni számítógépekben: szinte minden mikrogéphez saját BASIC változat járt (Commodore BASIC, GW-BASIC, AppleSoft BASIC stb.). 1985-ben a Microsoft kiadta a ''QuickBASIC''-et PC-re, ami már szerkesztőfelülettel és fordítóval segítette a BASIC programozókat. A '''szoftverfejlesztő eszközök''' terén a ’80-as évek nagy újítása a '''visual''' (vizuális) fejlesztői környezetek megjelenése. 1988-ban a Microsoft kiadta a ''Visual Basic'' elődjét jelentő ''QuickBasic Extended''-et (QuickBASIC 4.5), majd 1991-ben jött a Visual Basic maga, de ennek alapjai a ’80-as évek végi integrált környezetekre nyúlnak vissza. A '''Turbo Pascal''' (Borland) 1983-as megjelenése forradalmasította az IDE fogalmát PC-n: a szerkesztő, fordító és futtató integrálva, villámgyors fordítással tette lehetővé a fejlesztést – a Turbo Pascal és később Turbo C, Turbo C++ a fejlesztők széles körében népszerű eszköz lett. A '''verziókezelés''' szélesebb körű használata is az ’80-as években terjedt el: a Unix világban 1986-ban megjelent a ''RCS'' (Revision Control System), majd 1990-ben a ''CVS'' (Concurrent Versions System) – ezek lehetővé tették nagy szoftverprojektek kódbázisának egyidejű kezelését több fejlesztő között. A '''hálózati programozás''' is új eszközöket kapott: 1984-ben a BSD Unix 4.2 bevezette a ''sockets API''-t, ami a hálózati kommunikáció de-facto sztenderdjévé vált, és amelyen keresztül készült el sok internetes szoftver (FTP, SMTP, etc.). 1989-re pedig a Tim Berners-Lee által javasolt ''World Wide Web'' protokollok (HTTP, HTML) kidolgozása megkezdődött – ez még nem programozási nyelv, de új ''jelölőnyelv'' (HTML) és ''átviteli protokoll'' (HTTP) születését jelentette, melyeket a ’90-es évek programozói már bőszen használtak webfejlesztéshez. <span id="alkalmazási-területek-4"></span> === Alkalmazási területek === Az 1980-as években a számítástechnika mindennapivá válása gyökeresen átalakította az alkalmazási területeket. '''Otthon és oktatás''': A személyi számítógépek – ZX Spectrum, Commodore 64, Apple II, IBM PC és klónjaik – tömegesen elterjedtek az otthonokban és iskolákban. Ezáltal a gyerekek és felnőttek milliói találkoztak először számítógéppel, általában játék vagy tanulás céljából. Az oktatásban megjelent az informatika mint tantárgy, és a diákok BASIC-ben programoztak iskolai mikrogépeken. Az '''irodai munka''' radikális átalakuláson ment át a PC-k és szoftvercsomagok révén. 1983-ban a ''Lotus 1-2-3'' program (Lotus Development Corporation) egyesítette a táblázatkezelést, grafikonrajzolást és alapszintű adatbázis-kezelést egy MS-DOS alkalmazásban – ez a program az üzleti világban az IBM PC egyik húzóalkalmazása lett, a VisiCalc utódaként. A szövegszerkesztés terén a WordStar (1981) mellett 1983-ban a '''Microsoft Word''' (DOS-ra) és 1985-ben a '''Aldus PageMaker''' (Macintoshra) megjelenése kiemelhető. A PageMaker és az Apple LaserWriter nyomtató (PostScript-alapú) párosa lehetővé tette az ''asztali kiadványszerkesztést (desktop publishing)'', ami addig drága szedőgépeket igényelt. Ennek eredményeként kis kiadók, irodák is készíthettek nyomdai minőségű anyagokat – az 1985-ös Mac + LaserWriter + PageMaker triumvirátust sokan a DTP forradalom kezdetének tartják. A '''hálózatok és kommunikáció''' robbanása is az évtizedhez köthető: 1983. január 1-jén az ARPANET hivatalosan átállt a TCP/IP protokollra – ezt tekinthetjük az internet születésnapjának. Innentől kezdve gyorsulni kezdett a hálózat bővülése. 1985-ben létrejött az NSFNET az USA-ban, ami az egyetemeket kapcsolta össze nagy sávszélességű gerinchálózattal, felváltva fokozatosan az ARPANET-et. 1988-ra nemzetközi méretű, TCP/IP-t használó hálózat alakult ki (ekkor csatlakozott Magyarország is először egy email átjárón keresztül, majd 1990-ben teljes értékűen). A ’80-as években ugyan az „internet” még főként tudományos intézmények eszköze volt, de már ~100 000 számítógép csatlakozott rá, és ekkor jelentek meg az első internetes szolgáltatások a nagyközönség számára: pl. 1989-ben indult a ''PSINet'' mint az első kereskedelmi internet-szolgáltató (ISP) az USA-ban. Az e-mail ekkorra már az üzleti életben is mindennapossá vált, legalábbis a technológiai szektorban – 1982-ben meghatározták az SMTP protokollt szabványként. 1988 novemberében azonban figyelmeztetést is kapott az internet közössége: a ''Morris-féreg'' vírusfertőzés átmenetileg megbénította a hálózat jelentős részét, mintegy 6000 gépet megfertőzve a ~60 000-ből, ezzel történelmi első nagy internetes támadásként vonult be. A Morris-féreg ráirányította a figyelmet a hálózati biztonság kérdésére, és közvetve hozzájárult a CERT megalakulásához 1988-ban az incidenskezelés koordinálására. A '''szórakoztatóipar''' és média digitalizációja is felgyorsult. A filmekben megjelent a számítógépes grafika: 1982-ben a ''Tron'' film úttörő módon használt CGI jeleneteket, 1984-ben a ''The Last Starfighter'' teljes egészében számítógéppel generált űrcsatát tartalmazott. 1986-ban a '''Pixar''' kiadta az első teljesen számítógéppel animált rövidfilmet (''Luxo Jr.''), jelezve hogy a rajzfilm-animációban is itt a digitális kor. A zenei világban a digitális szintetizátorok és a ''MIDI szabvány'' (1983) lehetővé tették különböző eszközök összekapcsolását és számítógéppel vezérelt zeneszerzést. A hangrögzítés is áttért digitális formátumokra: 1982-ben a CD bevezetése, 1987-ben az első ''MP3'' algoritmus prototípus (a végleges szabvány 1993-ban jött ki). A '''videójátékok''' a ’80-as években hatalmas iparággá váltak: a Nintendo és Sega konzolok milliók otthonába jutottak el, míg a PC-k és otthoni számítógépek is platformot biztosítottak ezerféle játéknak. 1984-ben jelent meg a máig híres ''Tetris'' (Alekszej Pazsitnov), 1985-ben a ''Super Mario Bros.'', 1989-ben a ''SimCity'' és a ''Prince of Persia'' – hogy csak néhány meghatározót említsünk. A játékok fejlődése hajtotta a grafikushardver és a hangkártyák fejlődését is: 1989-ben a '''Creative Labs''' kiadta az első ''Sound Blaster'' hangkártyát, ami szabvánnyá tette a PC-kben a polifonikus hangokat és digitális audiólejátszást. <span id="fontos-idézetek-és-koncepciók-4"></span> === Fontos idézetek és koncepciók === Az 1980-as évek számos szállóigéje közül néhány örökre beégett az informatika történetébe. 1981-ben, amikor az IBM PC megjelent 640 kB maximális konvencionális memóriával, Bill Gates-nek tulajdonítottak egy kijelentést: ''„640K mindenkinek elég kell legyen”''. Gates később többször cáfolta, hogy ezt szó szerint így mondta volna, de a mondás elterjedt, mint a számítástechnikai jóslatok kudarcának jelképe – a szoftverek ugyanis pár éven belül meghaladták ezt a memóriaigényt. 1983-ban az '''Apple''' bemutatkozó reklámfilmje (rendezte Ridley Scott) a szürke diktatúra elleni lázadó nővel az IBM-et mint ''„Big Brother”''-t ábrázolta, és azt sugallta, hogy ''„1984” nem úgy lesz, ahogy Orwell megírta, mert jön a Macintosh, ami felszabadítja a számítástechnikát”''. A reklám végén hangzik el: ''„És megtudod, miért nem lesz 1984 olyan, mint 1984”''. Ez a spot egy korszak reklámkultúrájának ikonja, és az Apple küldetéstudatát fejezte ki. 1985-ben, a Microsoft Windows indulásakor '''Steve Jobs''' azzal vádolta a Microsoftot, hogy ''„nincs bennük eredetiség”'', mire állítólag '''Bill Gates''' így válaszolt: ''„Steve, azt hiszem, hogy mindketten egy gazdag szomszéd Xerox gépházába törtünk be, hogy ellopjunk egy tévét, csak te előbb értél oda és azt mondod, én loptam el tőled”''. Ez a csípős megjegyzés utal arra a köztudott tényre, hogy mind az Apple, mind a Microsoft merített ötleteket a Xerox PARC fejlesztéseiből a grafikus felület kapcsán. Gates ezzel kvázi elismerte, hogy a GUI alapötlete nem az Apple-é és nem is a Microsofté, hanem a Xeroxé – de a lopás metaforával érzékeltette a versengést is kettejük közt. '''Andy Grove''', az Intel vezérigazgatója mondta 1983-ban: ''„Csak a paranoiások maradnak fenn”'' („Only the paranoid survive”), utalva ezzel arra, hogy az állandó versenyben a folyamatos éberség és újítás képessége a kulcs – ez a mondás később könyvcímként is híressé vált, és a Szilícium-völgy cégkultúrájának mottója lett. 1989-ben, amikor a World Wide Web ötlete megszületett '''Tim Berners-Lee''' fejében, sokan kétkedtek. Akkoriban hangzott el a vélemény néhány tudóstól: ''„Ki akarhatná az egész világot behálózó hypertextet használni? Kinek van erre ideje?”''. Ez inkább utólag feljegyzett anekdota, de jól mutatja, hogy még az internetes forradalom küszöbén sem látta mindenki előre a változás mértékét. <span id="nyílt-problémák-és-versenyek-4"></span> === Nyílt problémák és versenyek === Az 1980-as években számos nyílt probléma konkretizálódott, melyek megoldása a következő évtizedek feladata lett. Az egyik ilyen a '''számítógép-hálózatok összekapcsolása''' globális méretekben. Bár a TCP/IP megszületett és az internet növekedett, nyitott kérdés volt a skálázódás (a címek, routing kérdései – amit később az IPv6, BGP protokoll stb. oldott meg részben), valamint a hozzáférés demokratizálása: a ’80-as évek végén az internet még főleg egyetemi és kutatóhálózat volt, a nagy nyitás 1989-1990-ben indult, de a hogyan és miként sok szempontból nyitott volt. A '''szoftverek komplexitása''' tovább nőtt, és bár a struktúrált és objektumorientált módszerek segítettek, a ''„szoftverválság”'' még nem múlt el. 1986-ban '''Fred Brooks''' kiadott egy híres esszét ''„No Silver Bullet”'' (Nincs csodafegyver) címmel, amelyben kifejtette, hogy nincs egyetlen varázsmódszer vagy eszköz, ami tízszeres javulást hozna a szoftverfejlesztés termelékenységében. A ’80-as évek végére ezért még mindig nyílt problémaként állt, hogyan lehet megbízható, nagy szoftverrendszereket határidőre és költségvetésen belül szállítani. Erre a válaszok (pl. formális módszerek, fejlett fejlesztői eszközök, később agilisan moduláris metodológiák) a későbbiekben érkeztek. A '''szellemi tulajdon''' és ''„look-and-feel”'' viták is nyitott kérdések maradtak. Az Apple vs. Microsoft per egészen 1997-ig húzódott (végül megegyeztek: Microsoft befektetett az Apple-be, cserébe az Apple ejtette a pert). Közben a nyílt forráskódú mozgalom erősödött: 1989-ben kiadták a '''GNU General Public License''' (GPL) 1.0 verzióját, ami a szabad szoftverek jogi keretét teremtette meg. A zárt vs. nyílt szoftverek versenye és együttélése egyre inkább a figyelem középpontjába került, de egyelőre a zárt forrású szoftver dominanciája nyilvánvaló volt (Microsoft ekkorra a szoftveripar óriásává nőtt, az FSF pedig még csak a fundamentumokat rakta le). A '''piaci verseny''' extrémen kiélezett volt: a PC-piacon 1987-88-ra a tajvani klóngyártók és a Compaq vezette olcsóbb klónok kiszorították az IBM-et a vezető pozícióból – nyitott kérdés volt, az IBM tudja-e tartani vezető szerepét (nem tudta). Az Apple a Mac sikeres rajtja után 1985-ben belső konfliktus miatt elvesztette Steve Jobs-ot (akit eltávolítottak a cégből), és a késő ’80-es évekre az Apple piaci részesedése stagnált, majd csökkenni kezdett, nyitva hagyva a kérdést, túléli-e a cég a következő évtizedet (ez 1997-98 körül vált kritikus kérdéssé, mire Jobs visszatért). A mikroprocesszoroknál az '''Intel vs. Motorola vs. RISC''' háború körvonalazódott: nyitott volt, hogy a RISC architektúrák átveszik-e a vezetést. A ’80-as évek végén úgy tűnt, a RISC munkaállomások (Sun, SGI, IBM) technikai fölényben vannak a PC-kkel szemben, de nyitott maradt, hogy ez a fogyasztói piacon is megjelenik-e (végül a PC vonal maradt domináns x86-tal, a RISC pedig az 1990-es években inkább a beágyazott és mobil szegmensben hódított, lásd ARM). A '''mesterséges intelligencia''' újabb reneszánsza is a ’80-as évekhez köthető: az ún. ''„második AI nyár”'' időszaka volt ez, különösen a szakértői rendszerek térnyerése miatt. Vállalatok dollár százmilliókat öltek olyan AI rendszerfejlesztésbe, ami speciális problémákat oldott meg (pl. orvosi diagnosztika, hitelbírálat). Nyitott maradt azonban, hogy ezen rendszerek mennyire skálázhatók és általánosíthatók – a válasz az lett, hogy a legtöbb szakértői rendszer csak szűk területen működik jól, és az AI ismét átmeneti csalódást okozott a 80-as évek végére. A szélesebb értelemben vett mesterséges intelligencia, különösen a neurális hálózatok, 1986-ban újra előtérbe kerültek (Rumelhart és McClelland munkái a visszaterjesztés algoritmusáról), de gyakorlati sikerük még váratott magára a korlátozott számítási kapacitás miatt. Versenyek terén a ’80-as években '''nemzetközi diákolimpiák''' is indultak: 1989-ben tartották meg az első '''Nemzetközi Informatikai Diákolimpiát (IOI)''' Bulgáriában, jelezve, hogy a programozási versenyek már a középiskolás szintre is kiterjedtek világszerte. Az ACM ICPC is növekedett és 1989-ben már 30+ ország egyetemi csapatai vettek részt. Az '''AI versenyek''' közül a számítógépes sakkban 1988-ban az IBM Deep Thought programja megnyerte a világbajnokságot és kihívta Kaszparovot (1989-ben játszottak is, Kaszparov még nyert; Deep Thought utódja lett a ’90-es évek Deep Blue-ja). Emellett 1980 óta évente megrendezték a Loebner-díjat a Turing-teszt jellegű beszélgető AI-knak – ezek show-jellegű versenyek voltak, melyeket egyik program sem nyert meg meggyőzően (és máig nem nyert „teljes Turing-tesztet” senki). Az '''1980-as évek''' végére a számítástechnika világa elképesztően kitágult, de ezzel új kihívások érkeztek. A ''hidegháború vége'' (1989) nyomán a korábban katonai célú internet megnyílt a civil szféra felé, megteremtve az 1990-es évek dot-com korszakának alapjait. A PC-k mindenhol ott voltak, de a szoftverek és hardverek interoperabilitása, a szabványok harca és a felhasználói igények kielégítése folyamatos versenyt diktált a cégeknek. Az évtized nyitott kérdései, – hogyan integráljuk globálisan a hálózatokat, hogyan kezeljük a növekvő szoftverkomplexitást, hogyan védjük meg az adatokat és rendszereket – közvetlenül vezettek a következő évtized technológiai irányaihoz. <span id="es-évek-az-internet-és-a-multimédia-forradalma"></span> == 1990-es évek – Az internet és a multimédia forradalma == <span id="találmányok-és-első-használatok-5"></span> === Találmányok és első használatok === A 1990-es évek központi találmánya kétségtelenül a '''Világháló (World Wide Web)''' volt. 1990 végén '''Tim Berners-Lee''' a CERN-ben elkészítette a WorldWideWeb nevű első böngészőt és webszervert, miután 1990. november 12-én beadott javaslatában használta először a „World Wide Web” kifejezést. 1991 augusztusában a web nyilvánossá vált az interneten: Berners-Lee közzétette a WWW leírását és forráskódját nyíltan, ami lehetővé tette, hogy bárki futtasson webszervert és fejlesszen böngészőt. A web feltalálása egyesítette a hypertext koncepcióját az internet protokolljaival, és rövidesen hatalmas lendületet adott az internet elterjedésének. 1993-ban jelent meg az '''NCSA Mosaic''' böngésző, az első széles körben használt grafikus web-böngésző, Marc Andreessen és csapata jóvoltából. A Mosaic népszerűsége miatt 1994-től a web forgalma exponenciálisan nőni kezdett. 1994-ben '''Netscape''' (Andreessen új cége) kiadta a Netscape Navigator böngészőt, amely a ’90-es évek közepének domináns böngészőjévé vált. A web mellett számtalan internetes technológia született: 1991-ben indult a '''Gopher''' (egy menürendszeres internetes információkereső protokoll) – bár a web hamar túlnőtt rajta, a Gopher újdonsága jelezte az online információelosztás igényét. 1998-ban jelent meg a '''Google''' kereső (először Stanford-projektként), amely forradalmasította a weben való keresést intelligens PageRank algoritmusával. A számítógépes hardverben a ’90-es évek hozta el a '''gigahertz határának''' megközelítését: 1993-ban az Intel kiadta a ''Pentium'' processzort (P5 mikroarchitektúra), ami 60/66 MHz-en futott, de az évtized végére, 1999-re az Intel Pentium III már 500 MHz felett járt, az '''AMD''' Athlon pedig 750 MHz-nél. 2000-ben (közvetlenül az évtized végén túl) lépte át először kereskedelmi CPU az 1 GHz-et (AMD Athlon, majd Pentium III). A mikroprocesszoroknál nyílt kérdés volt a hőtermelés és órajel-skálázás, amit egy darabig a félvezető csíkszélességek csökkentése megoldott. A '''tárolástechnika''' ugrásszerű fejlődést mutatott: a merevlemezek kapacitása a 90-es években a megabájtos tartományból gigabájtossá nőtt. 1991-ben az első 3,5”-os 1 GB-s HDD megjelent, 1998-ra már 10-20 GB-os merevlemezek voltak a PC-kben. A CD-ROM a ’90-es évek elején rohamosan elterjedt mint szoftverterjesztési és adattárolási médium. 1995-ben a '''DVD''' formátum szabványosodott (és 1997-től jelentek meg a DVD-lejátszók, PC-s DVD-ROM-ok), ami 4,7 GB kapacitást nyújtott optikai lemezen, megnyitva az utat a digitális videó és nagy szoftverek terjesztése előtt. A 90-es években a '''mobileszközök''' is kezdték integrálni a számítástechnikát: 1992-ben az IBM bemutatta az ''IBM Simon'' személyi kommunikátort, amit az első okostelefonnak tekintenek (a funkciói közt e-mail, fax, naptár is volt). Bár kereskedelmileg nem lett átütő siker, a Simon jelezte a jövőt. 1996-ban megjelent a '''Palm Pilot''' kéziszámítógép, ami a PDA-k (Personal Digital Assistant) korszakát indította el. Ezek a zsebgépek korlátozottak voltak, de naptár, címtár, jegyzetek kezelésére és némi szinkronizálásra használták őket – a mobil számítástechnika csírái. <span id="hardverrendszerek-és-processzorok-5"></span> === Hardverrendszerek és processzorok === Az évtized elején a processzorpiacot az '''Intel''' uralta a Pentium sorozattal. 1995-ben megjelent a ''Pentium Pro'' (P6 architektúra), amely a szerverek és munkaállomások piacát célozta, és újdonságként a processzorlapkára integrált másodszintű cache-t tartalmazott. A Pentium Pro 200 MHz-es csúcssebességével és 5,5 millió tranzisztorával a csúcsteljesítményt képviselte a maga idejében. 1997-ben az Intel kiadta a ''Pentium II''-t, amely a Pentium Pro magját kombinálta multimédiás kiterjesztésekkel (MMX) – ezzel a PC-k már jobban boldogultak grafikával, hanggal, videóval. 1999-ben a ''Pentium III'' is megjelent (Katmai mag 450–600 MHz-en), SSE utasításkészlettel a 3D grafika gyorsítására. Az '''AMD''' mint versenytárs a ’90-es években erősödött meg: 1999-ben kihozták az ''Athlon'' processzort (K7 architektúra), amely 500–750 MHz között futott és sok tekintetben felülmúlta az azévi Pentium III-at. Az AMD Athlon volt az első komoly kihívója az Intelnek a csúcsteljesítmény terén, megelőlegezve a 2000-es évek CPU „óraszámháborúit”. A '''RISC architektúrák''' a munkaállomásokban és szerverekben érték el csúcspontjukat: a Sun SPARC, SGI MIPS, IBM POWER, HP PA-RISC processzorcsaládok mind új generációkkal jöttek ki. 1995-ben az '''IBM és Motorola''' közösen piacra dobta a ''PowerPC 604e'' processzort, ami a Macintoshokban és IBM munkaállomásokban futott, 350 MHz körüli órajelekkel. A DEC 1992-ben bemutatta az ''Alpha'' 64 bites RISC processzort, ami éveken át a világ leggyorsabb CPU-jának számított órajelenkénti műveletekben. Az Alpha 1996-ban már 500 MHz-en járt, messze megelőzve az Intel órajeleit akkoriban. Ezzel együtt a RISC vs CISC vita is lezárult abban az értelemben, hogy mindkét oldal közeledett egymáshoz: az Intel P6 architektúra belsőleg már mikro-utakra törte a CISC utasításokat (dynamikus utasításfordítás), míg a RISC chip-ek egyre több tranzisztort kezdtek használni cache-re és speciális funkciókra, nem csupán „egyszerűek” voltak. Végső soron az x86 vonal maradt a PC-knél domináns, de a RISC architektúrák integrálódtak a beágyazott rendszerekbe és később a mobil eszközökbe. A '''perifériák''' és buszrendszerek terén is jelentős fejlesztések történtek. 1993-ban az Intel bevezette a ''PCI buszt'', ami leváltotta az ISA/EISA buszokat a PC-ben, lényegesen nagyobb átviteli sebességet és plug-and-play konfigurációt kínálva. 1997-ben megjelent az ''AGP port'' a grafikus kártyák számára, dedikált sávszélességet adva 3D grafikának. 1996-ban a '''USB 1.0''' szabvány megszületett (az első széles elterjedése 1998 körül, USB 1.1 formájában történt), ami egységesítette a csatlakozófelületet a billentyűzet, egér, nyomtató, kamera stb. számára. A '''grafikus gyorsítás''' a PC-ben óriásit lépett: 1996-ban a 3dfx cég kiadta a ''Voodoo Graphics'' 3D gyorsítókártyát, ami forradalmasította a PC-s játékok megjelenítését. Ezzel kezdetét vette a GPU-k (Graphics Processing Unit) felemelkedése. 1999-ben az NVIDIA piacra dobta a ''GeForce 256'' GPU-t, amelyet az első ''„GPU”''-ként marketingeltek, mivel tartalmazott hardveres transzformációs és világítási (T&amp;L) egységet. Ez lehetővé tette, hogy a bonyolult 3D számításokat (mátrixtranszformációk, fénymodellek) a videókártya végezze, felszabadítva a CPU-t – a modern grafikus számítási paradigma kezdete. <span id="operációs-rendszerek-5"></span> === Operációs rendszerek === A 90-es évek elején a PC-k többségén még '''MS-DOS''' futott, gyakran grafikus felülettel (Windows 3.0/3.1) kiegészítve. 1990 májusában a Microsoft kiadta a ''Windows 3.0''-t, amely az első széles körben sikeres Windows verzió lett, multitask módon futtatva több DOS programot a 386-os processzor védett módját kihasználva. A Windows 3.0 és a rá következő 3.1 (1992) már valódi fenyegetést jelentett a Macintosh számára, mert egyre több felhasználó váltott át a hasonló képességeket kínáló, de olcsóbb PC platformra. <ol start="1995" style="list-style-type: decimal;"> <li>augusztus 24-én aztán megérkezett a ''Windows 95'', amely 32 bites, preemptív multitasking operációs rendszer volt, integrált grafikus felülettel, és maga mögött hagyta a régi 640 KB limitet. A Windows 95 hatalmas marketingkampány kíséretében debütált, és percek alatt elfogyott az üzletekből. Beépítve tartalmazta az akkor új '''Internet Explorer 1.0''' böngészőt is (melyet a Plus! csomagban lehetett külön telepíteni, majd Windows 95 OSR2.5-től integráltan jött). A Windows 95 egyesítette a DOS/Windows vonalakat egyetlen termékbe, és megkönnyítette a felhasználók számára az internet csatlakozást is (bár az igazi integráció a Windows 98-ban történt).</li></ol> A '''Macintosh''' vonalon az Apple 1991-ben kiadta a ''System 7''-et, egy továbbfejlesztett, színes GUI-s operációs rendszert, amely memóriavédelmet ugyan még nem nyújtott, de multitaskingot és sok új funkciót igen. Az Apple azonban egyre inkább lemaradt az OS-fejlesztésben a 90-es években; a Copland nevű teljesen újraírt OS projektjük kudarcot vallott, és végül 1997-ben az Apple úgy döntött, külső forrásból szerzi be új generációs OS-ét – megvásárolták '''NeXT''' vállalatot, amellyel Steve Jobs visszatért, és a NeXTSTEP alapjain építették fel a későbbi Mac OS X-et (de ez már 2001-ben jelent meg, a 90-es évek végén folyt a fejlesztése). A '''UNIX származékok''' erősen jelen voltak a szervereken és munkaállomásokon. 1991-ben azonban egy új szereplő lépett színre: '''Linus Torvalds''' finn hallgató bejelentette, hogy hobbiból fejleszt egy szabad operációs rendszermagot a PC-jére – ez lett a ''Linux kernel''. Az 1991. augusztus 25-i híres Usenet üzenet így kezdődött: ''„Hello mindenki… Egy (szabad) operációs rendszeren dolgozom (csak hobbi, nem lesz nagy és profi, mint GNU) 386(486) AT klónokra”''. Torvalds 1991 őszén publikálta a Linux 0.01 kódját, és 1994 márciusában kiadta az első hivatalos stabil változatot, a ''Linux 1.0''-t. A Linux a ’90-es évek közepén robbanásszerűen fejlődött, köszönhetően a GNU projekt által biztosított szoftvereszközöknek és a nemzetközi közreműködői közösségnek. 1999-re a Linux kernel 2.2-es verziója jelent meg, és becslések szerint több mint 10 millió felhasználó futtatott Linuxot világszerte, főleg szervereken és technikai környezetben. A Linux a nyílt forráskódú mozgalom diadalának számított, és a dot-com éra internetes infrastruktúrájának kulcselemévé vált (webszerverek, DNS szerverek, stb. gyakran Linuxon futottak). A '''Windows NT''' vonal is elindult: 1993-ban a Microsoft kiadta a ''Windows NT 3.1''-et, egy teljesen 32 bites, üzleti szerverekre és munkaállomásokra szánt OS-t (Dave Cutler vezetésével, VMS alapelvekre építve). Ez a vonal a 90-es évek végére találkozott a fogyasztói vonallal: 1996-ban jött a Windows NT 4.0 (amely Windows 95-szerű felületet kapott), majd 2000-ben a Windows 2000 – utóbbi már egyesítette a felhasználói és vállalati Windows vonalat NT alapon, kvázi a Windows 95/98 utódjaként is működött. A '''hálózati operációs rendszerek''' terén a Novell NetWare uralma a ’90-es években fokozatosan csökkent, ahogy a Microsoft 1996 után megjelent a Windows NT Server termékcsaláddal, integrált tartománykezeléssel (Active Directory 1999-ben készült el). A nyílt szabványok is tért nyertek: 1998-ban jelent meg a ''Samba'' szerver, ami lehetővé tette, hogy UNIX/Linux gépek Windows hálózatokban fájl- és nyomtatómegosztást végezzenek, ezzel nyitott forrású alternatívát kínálva a Windows szerverfunkciókra. A '''kézi eszközök OS-ei''' is megjelentek: 1996-ban a Palm OS a PDA-kon, 1996-ban a Windows CE (későbbi Pocket PC, Windows Mobile) a kéziszámítógépeken. Ezek még kezdetlegesek voltak, de megalapozták a mobil operációs rendszerek fejlődését. <span id="programozási-nyelvek-és-fejlesztői-eszközök-5"></span> === Programozási nyelvek és fejlesztői eszközök === A 90-es években a programozási nyelvek terén két nagy trend volt: az '''objektumorientált programozás''' térnyerése a nagy projekteknél, és az '''internet/programozás''' új nyelveinek megjelenése. 1995 körül valóságos nyelvdömping történt: * '''Java''': 1995 májusában a Sun Microsystems bemutatta a Java nyelvet és platformot (eredetileg 1991-től „Oak” kódnéven fejlesztették). A Java mottója „Write Once, Run Anywhere” lett, utalva a virtuális gépre (JVM) épülő, platformfüggetlen bytecode végrehajtásra. A Java gyorsan népszerű lett a webes (appletek a böngészőben) és szerveroldali fejlesztésben egyaránt, mivel objektumorientált, biztonságos (pointerek nélküli), és gazdag standard könyvtárral rendelkezett. * '''JavaScript''': 1995-ben a Netscape cég kifejlesztette a JavaScript nyelvet (Brendan Eich munkája), amelyet a Netscape Navigator böngészőbe építettek be, hogy dinamikus interakciókat tegyen lehetővé weboldalakon. A JavaScript (eredetileg LiveScript) névválasztása marketingfogás volt, a nyelvnek kevés köze volt a Javához, viszont ez lett a szabványos kliens-oldali szkript nyelv a weben. 1996-ra a Microsoft is implementálta (JScript néven) az Internet Explorerbe, majd az EcmaScript szabvány 1997-ben formalizálta a nyelvet. * '''PHP''': 1995-ben '''Rasmus Lerdorf''' nyilvánosságra hozta a PHP/FI nevű egyszerű szkriptet CGI feladatokra, amelyből kinőtt a PHP nyelv. A PHP (PHP: Hypertext Preprocessor) kifejezetten webes szerveroldali programozásra készült, beágyazható HTML-be. 1998-ra a PHP3 verzió már széles körben használt volt dinamikus weboldalak létrehozására, köszönhetően az egyszerű szintaxisának és az ingyenes elérhetőségének. * '''Python''': bár a Python első verziója 1991-ben született ('''Guido van Rossum''' alkotása), a nyelv igazán a ’90-es évek második felében kezdett terjedni a programozók között, 1.5-ös verzió (1998) körül. A Python a tiszta, olvasható szintaxisával és sokoldalú standard könyvtárával a gyors fejlesztést igénylő területeken (szkriptek, adminisztráció, web) kedvelt nyelv lett. * '''Ruby''': 1995-ben Japánban '''Yukihiro Matsumoto (Matz)''' létrehozta a Ruby nyelvet, amely objektumorientált és script nyelv egyben, a Perl és Smalltalk inspirációival. Ruby nyugaton a ’90-es években még kevéssé volt ismert, de Japánban népszerű lett, és a 2000-es években a Ruby on Rails keretrendszer hozta meg nemzetközi sikerét. A „régi” nyelvek közül a '''C és C++''' továbbra is dominált a rendszerszintű és alkalmazásfejlesztésben. A Microsoft például 1992-ben kiadta a ''Visual C++'' fejlesztőkörnyezetet. Az '''object-oriented paradigm''' széles körű elfogadását jelzi, hogy 1990-ben az ISO/IEC szabványosította a C++ nyelvet, és a nagy szoftverek (operációs rendszerek GUI részei, irodai szoftvercsomagok stb.) gyakran C++-ban íródtak. Az '''adatbázis-kezelés''' terén a '''SQL''' nyelv vált ipari szabvánnyá (1986-ban az ANSI, 1987-ben az ISO szabványosította, majd jöttek bővítések a ’90-es években). Az Oracle, IBM DB2, Sybase, Microsoft SQL Server mind SQL alapú relációs adatbázisokat kínált, és 1995-ben megjelent a ''MySQL'' is nyílt forráskódú alternatívaként. A '''fejlesztői eszközök''' hihetetlen fejlődést mutattak. A 90-es évek volt a '''IDE-k virágkora''': Microsoft Visual Studio (1997-től integrált csomagként), Borland Delphi (1995-ben jelent meg, a Turbo Pascal utóda, vizuális komponens alapú fejlesztésre koncentrálva), Borland C++ Builder (1997). Ezek az eszközök WYSIWYG jellegű grafikus felület-tervezőkkel és erőteljes debuggerekkel könnyítették a fejlesztést. A '''forráskód-kezelő rendszerek''' nagyvállalati használatra is beértek: 1995-ben a Microsoft kiadta a ''Visual SourceSafe''-et, 1990-ben megjelent a CVS nyílt forráskódú verziója. A 90-es évek végén már a ''változatkövetés'' és ''bug tracking'' rendszerek használata bevett gyakorlat lett a szoftverfejlesztésben. A '''hálózatbiztonság és titkosítás''' is a programozási eszköztár részévé vált: 1995-ben publikálták a '''SSL''' protokollt (Secure Sockets Layer) a Netscape-nél, ami a webes forgalom titkosítását oldotta meg (elődje a mai TLS-nek). A nyilvános kulcsú titkosítás terén a '''PGP (Pretty Good Privacy)''' programot '''Phil Zimmermann''' 1991-ben tette közzé, hogy bárki használhasson erős titkosítást e-mailhez – ami miatt aztán évekig jogi csatákat vívott az amerikai hatóságokkal (akkoriban a titkosító algoritmusokat hadi exportcikknek minősítették). Végül a titkosítás széles körű használata győzött: 1999-ben az USA feloldotta a legszigorúbb exportkorlátozásokat, a böngészők és e-mail kliensek pedig natívan integrálták a titkosított protokollokat. <span id="alkalmazási-területek-5"></span> === Alkalmazási területek === A 90-es évek messzemenően átalakították a mindennapi életet a számítógépes technológia alkalmazása révén. A '''világháló''' megszületése és elterjedése új alkalmazási területeket nyitott: * '''Kommunikáció''': Az e-mail mellett megjelent a ''csevegés (chat)'' és az ''instant messaging''. 1988-ban a '''IRC (Internet Relay Chat)''' protokoll lehetővé tette a valós idejű szöveges beszélgetéseket csoportokban. 1996-ban indult az '''ICQ''', az első széles körben elterjedt instant üzenetküldő program, majd követte 1997-ben az AOL Instant Messenger és a Microsoft későbbi MSN Messenger (1999). Ezek valós időben kötötték össze a felhasználókat, a „szöveges beszélgetés” a neten mindennapossá vált. A 90-es évek végén a mobiltelefonok SMS üzenetküldése is robbanásszerűen népszerű lett, így a fiatal generációk gyakorlatilag folyamatos digitális kapcsolatban álltak egymással. * '''Információkeresés és portálok''': A web növekedésével szükség lett keresőmotorokra és webkatalógusokra. Az első generációs keresők (Archie, Veronica – még Gopherhez; majd WebCrawler, Lycos, AltaVista – webhez) mind a ’90-es évek közepén indultak. 1994-ben '''Jerry Yang és David Filo''' létrehozták a ''Yahoo!'' kézzel szerkesztett webkatalógust, ami portállá fejlődött. 1995-re a Yahoo, Excite, Lycos, Infoseek, AltaVista mind versengtek a weben információt keresők kegyeiért. A '''Google''' 1998-as indulásával a hatékonyság sokszorosára nőtt (PageRank alapú találatrendezés), és gyorsan a vezető keresővé vált. Ezzel új iparág, az ''SEO (Search Engine Optimization)'' is született, mert a cégek felismerték, milyen fontos, hogy weblapjaik előkelő helyen szerepeljenek a keresőkben. * '''Elektronikus kereskedelem''': A 90-es évek közepén megalakultak az első dot-com cégek, amelyek az internetet kereskedelmi célra használták. 1994-ben '''Jeff Bezos''' megalapította az ''Amazon.com''-ot könyvárusként – mára globális e-kereskedelmi óriás. 1995-ben '''Pierre Omidyar''' útjára indította az ''eBay'' online piacteret, amely lehetővé tette bárkinek, hogy aukciókon értékesítsen bármit világszerte. 1999-ben a kínai '''Jack Ma''' megalapította az ''Alibaba'' B2B portált. Ezen pionírok által az e-kereskedelem bebizonyította életképességét: az 1998-as karácsonyi szezonban az Amazon hatalmas forgalmat bonyolított, ezzel beírva az internetet a kiskereskedelem történetébe. Ugyancsak 90-es évek végi jelenség a ''dot-com boom'' – internetes startup vállalatok százai alakultak, a tőzsde eufóriával reagált (NASDAQ index szárnyalt 1995-2000 között). Olyan cégek születtek ebben az időben, mint a ''Paypal'' (1998 – online fizetés), a ''Napster'' (1999 – zene-megosztó, ami a zeneiparnak hívta fel a figyelmét a digitális terjesztésre), a ''Google'' (1998). * '''Szórakoztatás és média''': A 90-es évek végére a digitális tartalomfogyasztás előfutárai már léteztek. 1996-ban megjelent a ''DVD'', ami 2000-re kezdte leváltani a VHS kazettákat. A számítógépek CD-meghajtói révén a zenehallgatás és később a CD-írók révén a zene másolása, CD-írás széles körben elterjedt (és aggasztotta a kiadókat). 1999-ben a Napster elhozta az MP3 fájlmegosztás lázát – ugyan jogi okokból 2001-re be is zárták, de Pandora szelencéje kinyílt: a peer-to-peer (P2P) fájlmegosztás és a digitális zene kora elkezdődött. A ''videojáték-ipar'' is hatalmas üzletté vált: 1991-ben a Super Nintendo hódított, 1994-ben kijött a ''Sony PlayStation'', ami CD-alapú játékkonzolként új generációt nyitott (1999-re a PlayStation eladásai meghaladták a 100 milliót). 1998-ban jelent meg a ''Pokémon'' jelenség (GameBoy játék és anime, ami világszerte őrületet okozott). A PC-s játékok is virágoztak: 1993-ban a ''Doom'' és 1996-ban a ''Quake'' lerakta az online multiplayer FPS alapjait, 1998-ban a ''StarCraft'' és ''Half-Life'' új műfaji csúcsokat döntött. Az ''e-sport'' fogalma megszületett (1997 Red Annihilation Quake bajnokság, 1998 StarCraft versenyek Dél-Koreában). * '''Film és animáció''': 1995-ben a Pixar kiadta a ''Toy Story''-t, a világ első teljes egészében számítógéppel animált egészestés filmjét, bizonyítva, hogy a CGI képes érzelmes, élvezetes mozit alkotni – a film hatalmas kasszasiker lett. Ettől kezdve a digitális animáció fontos ága lett a filmgyártásnak, és a kézzel rajzolt animáció lassan visszaszorult. A speciális effektusok terén is a 90-es évek forradalmat hoztak: 1991-ben a ''Terminátor 2'' folyékony fém T-1000 karaktere (Industrial Light &amp; Magic CGI-jával) új mércét állított, 1993-ban a ''Jurassic Park'' dinoszauruszai számítógépes animációval keltek életre, 1999-ben a ''Mátrix'' film bullet time effektje és a Star Wars előzménytrilógia (I. rész) 3D karakterei (Jar Jar Binks) mutatták, hogy a CGI szinte mindent lehetővé tesz a filmvásznon. A '''tudomány és technika''' terén is a számítógépek immár nélkülözhetetlenné váltak. A 90-es években a '''szuperszámítógépek''' listáján Japán és az USA versengett: 1993-ban indult a TOP500 lista, melynek élén sokáig az amerikai Intel Paragon, majd az ASCI Red állt, de 1996-ban a japán NEC Earth Simulator is csúcsközelben volt. A tudományos számítások (időjárási modell, kozmológia, anyagtudomány) mind HPC rendszereken futottak. 1997-ben az IBM ''Deep Blue'' számítógép '''sakkozásban legyőzte Garri Kaszparov''' világbajnokot – ezzel beteljesítve a fél évszázados kihívást és sokak számára bizonyítva a számítógépek „intelligenciáját” a szűk területen. A biológiában 1990-ben indult a '''Humán Genom Projekt''', amely gigászi mennyiségű DNS-szekvencia adatait csak komoly számítógépes erővel tudta feldolgozni – 2000-re elkészültek az emberi genom első változatával. Az internet pedig a tudományos együttműködést is meggyorsította: megjelentek az elektronikus folyóiratok, e-print szerverek (pl. arXiv 1991-től) és a tudósok e-mailen, weben keresztül osztották meg eredményeiket, felgyorsítva a kutatás ütemét. <span id="fontos-idézetek-és-koncepciók-5"></span> === Fontos idézetek és koncepciók === A 90-es évek tele volt optimista és pesszimista jóslatokkal a digitalizációval kapcsolatban. '''Bill Gates''' 1995-ben adta ki „The Road Ahead” című könyvét, amelyben vizionálta a „mindenhol jelenlévő számítástechnika” (pervasive computing) jövőjét és a „műsorszórás és számítástechnika konvergenciáját”. '''Nicholas Negroponte''' 1995-ös „Being Digital” könyvében bevezette a ''„from atoms to bits”'' koncepciót, miszerint a fizikai termékek (atomok) digitális formába (bitek) alakulása alapvetően változtat meg iparágakat (zenét, filmet, könyvkiadást). E jóslatok határozottan igaznak bizonyultak. '''Larry Page és Sergey Brin''' (a Google alapítók) mondása 1998-ból: ''„A tökéletes keresőmotor megértené pontosan, mit gondolsz, és pontosan azt adná, amit akarsz”''. Ez a hitvallás vezette a Google fejlesztéseit (PageRank algoritmus stb.), és előre vetíti a későbbi mesterséges intelligenciával megtámogatott keresést, ami mára kezd valósággá válni. '''„dot-com boom”''': E kifejezést a 90-es évek végén kezdték használni a technológiai tőzsdei buborékra utalva. Az akkor szállóigévé vált mondás ''„Get Big Fast”'' (Növekedj nagyra, gyorsan) Jeff Bezos stratégiája volt az Amazonnál, de sok dot-com cég követte: a piaci részesedést fontosabbnak tartották a profitnál, bízva abban, hogy a győztes mindent visz. Ez a koncepció vegyes eredményekhez vezetett: sok cég összeomlott a dot-com lufi kipukkanásakor (2000-2001), de akik túlélték (Amazon, eBay, Google), valóban dominánssá váltak. '''1999, Y2K''': A ’90-es évek végén a legnagyobb nyilvános figyelmet kapott informatikai téma az ''Y2K-probléma'' volt. Sok régi szoftverben és adatbázisban ugyanis csak két számjeggyel tárolták az évszámot, így 2000-re átfordulva potenciálisan hibásan értelmezhették volna (1900 vagy 2000). Az egész világon nagy erőkkel fogtak neki a rendszerek Y2K kompatibilissé tételének. '''„Y2K compliant”''' és '''„Y2K bug”''' lett a kifejezés, amit a laikus közönség is megtanult. Végül a hatalmas összefogásnak hála 2000. január 1-jén nem történtek nagyobb katasztrófák – utólag egyesek túlzott hisztériának tartották az egészet, pedig inkább arról volt szó, hogy a megelőző munka meghozta gyümölcsét. '''„Információs szupersztráda”''': Ezt a kifejezést '''Al Gore''' amerikai szenátor (későbbi alelnök) népszerűsítette a ’90-es évek elején a globális szélessávú hálózatok víziójára. Az “Information Superhighway” metafora segített a nyilvánossággal megértetni az internet jelentőségét, és politikai támogatást gyűjteni a távközlési infrastruktúra fejlesztéséhez. '''GNU GPL''' és a '''„szabad szoftver”''': '''Richard Stallman''' híres mondása ''„A szabad szoftver nem (csak) azt jelenti, hogy ingyenes (free as in free beer), hanem hogy szabad, mint a szólásszabadság (free as in free speech)”''. Ez a 90-es évek során terjedt el, mert sok félreértés adódott a „free software” kifejezés miatt. Emellett Stallman a „copyleft” fogalmát is megalkotta – szójáték a copyrighttal, azokra a licencekre utalva, amelyek biztosítják a szabadságjogok továbböröklődését. <span id="nyílt-problémák-és-versenyek-5"></span> === Nyílt problémák és versenyek === A 90-es évek végére, bár rengeteg kérdést megoldottak, számtalan új nyílt probléma merült fel, amelyek a következő évtizedeket formálták. Az '''internet szabályozása és biztonsága''' nyitott problémaként jelent meg. A dot-com boom idején felmerült a netes kereskedelem szabályozása (pl. internetes adózás kérdése), az online tartalmak (pl. szerzői jogvédelem Napster ügy kapcsán), és a kibertérben elkövetett bűncselekmények (hackelés, vírusok, csalások) elleni fellépés. 1998-ban elfogadták az USA-ban a ''Digital Millennium Copyright Act'' (DMCA) törvényt, ami az online szerzői jogi védelem sarokköve lett, bár sok vita övezte (a hackelés elleni részei miatt is). 1999-ben történt az egyik első nagy '''DDoS támadás''' (az eBay, Amazon, Yahoo ellen 2000 elején, egy MafiaBoy nicknevű fiatal által), ami ráirányította a figyelmet a hálózat sebezhetőségére. A biztonság nyitott gond maradt: 1998-ban a '''CIH/Chernobyl vírus''' sok kárt okozott, 1999-ben pedig a '''Melissa számítógépes vírus''' e-mailek tömeges küldésével terjedt és zavart keltett. Ezek mind előrevetítették a 2000-es évek internetes biztonsági kihívásait (vírusjárványok, adathalászat, hacker csoportok). A '''szélessávú internet''' igénye is nyitott kérdés volt: a 90-es évek végén a legtöbb felhasználó még betárcsázós (dial-up) modemmel kapcsolódott (33.6k, majd 56k), ami szűkös sávszélt adott. Bár már létezett DSL technológia (az első ADSL szabvány 1998-ban), ennek kiépítése a telefontársaságok részéről csak most indult. Nyitott kérdés volt, mennyire gyorsan tudnak az infrastruktúrák lépést tartani az egyre sávszélesség-éhesebb alkalmazásokkal (pl. Napster). Hasonlóképp a vezeték nélküli hálózatok: az első ''Wi-Fi'' szabvány, az IEEE 802.11b 1999-ben jelent meg, de még csak 11 Mbit/s-el. A wifi, majd a mobil internet (GPRS, később 3G) a 2000-es évek témája lett, de magja a 90-es évek végén vetődött el. A '''mobil számítástechnika''' nyitottan hagyta, ki és hogyan integrálja a telekommunikációt a számítástechnikával. A 90-es évek végén a mobiltelefonok már digitális GSM hálózatokon terjedtek (SMS-sel, 1998-tól WAP böngészőkkel kísérleteztek, sikertelenül), a PDA-k pedig külön eszközként léteztek. A konvergencia – okostelefon, mobilinternet – még gyerekcipőben járt (bár 1999-ben a Japán NTT DoCoMo i-Mode szolgáltatása már mobilon netezést kínált). Nyitott kérdés maradt, hogy egyesül-e a kézben tartott telefon és a kézben tartott számítógép – a válasz a 2000-es években az iPhone és Android formájában jött. A '''dot-com buborék''' kipukkanása 2000 körül nyitva hagyta, mely internetes cégek élik túl, és milyen üzleti modellel lesz fenntartható egy online vállalkozás. 1999-2000-ben sok cég a „szemgolyó” (látogatottság) alapján értékelte magát, a profitra kevés fókuszt helyezve. A részvénypiac 2000 tavaszán bedőlt, sok cég csődbe ment. Azonban a túlélők (Amazon, eBay, Yahoo, és nem sokkal később a Google) bizonyították, hogy az internetes gazdaság létező dolog. A nyitott kérdés az volt, hogyan lehet fenntartható bevételt generálni online szolgáltatásokból – erre a késő 2000-es években a hirdetés-alapú modellek (Google AdWords 2000-ben, később Web 2.0, közösségi média monetizáció) adtak választ. A '''magánélet védelme''' és '''kriptográfia szabadsága''' is kiélezett lett. 1991-ben, amikor a PGP kijött, az USA hatóságai vizsgálatot indítottak ellene, de a nyilvánosság nyomása miatt ejtették. 1993-ban az amerikai kormány egy „Clipper chip” nevű, lehallgathatóságot biztosító titkosító csip standardot javasolt, ám ez erős ellenállásba ütközött a szakmai és civil jogi szervezetek részéről, és végül megbukott. 1998-ban a ''„természetes szövetségesek”'' csoport (EFF stb.) kivívta, hogy a kormány enyhítse a titkosítás exportkorlátozását. Mégis, a magánszféra vs. biztonság vs. üzleti érdekek közti egyensúly máig nyitott problémákat eredményez (lásd: cookie-k és adatvédelem, 1999-ben az EU először adott ki irányelvet a személyes adatok védelméről; spam e-mailek – a világ első anti-spam törvényei 2003-ban jöttek). A 90-es évek végén a spam már komoly gond volt (a teljes e-mail forgalom jelentős része kéretlen reklám volt), de hatékony megoldás még nem létezett rá. Összegzésképpen a 90-es évek a ''digitális forradalom'' kiteljesedését hozta, és átvezette a társadalmat az új évezredbe, ahol a számítástechnika és internet a gazdaság, kultúra és mindennapi élet alapinfrastruktúrájává vált. A megválaszolatlan kérdések és új kihívások pedig megalapozták a következő évtizedek technológiai fejlődését és vitáit. ---- Az ezredforduló utáni évtizedekben a számítástechnika drámai fejlődésen ment keresztül, amely gyökeresen átalakította a mindennapi életet és a gazdaságot. A 2000-es évek elejét a dotkom lufi kipukkadása jellemezte, amely számos internetes startup bukásához vezetett. Ugyanakkor az internet és a világháló tovább terjedt, és olyan online óriások erősödtek meg, mint az Amazon és az eBay, amelyek sikeresen vészelték át a piaci átrendeződést. A következő évtizedekben az információs technológia egyre inkább behálózta a társadalmat: megjelentek az okostelefonok, közösségi hálózatok és felhőszolgáltatások, miközben a számítógépek teljesítménye és az adatok mennyisége exponenciálisan nőtt. A 2010-es évekre a mobil eszközök váltak elsődleges számítástechnikai platformmá, a mesterséges intelligencia pedig kézzelfogható eredményeket kezdett felmutatni a mindennapokban. A 2020-as évekre a számítástechnika az élet szinte minden területén kulcsszerepet játszik – a járványhelyzet felgyorsította a digitális átállást, az AI pedig soha nem látott képességekkel jelentkezett. Az alábbiakban évtizedenként áttekintjük a számítástechnika történetének főbb fejleményeit 2000 után, tematikus bontásban, bemutatva a technológiai újításokat és azok társadalmi hatásait. <span id="es-évek"></span> == 2000-es évek == <span id="mesterséges-intelligencia"></span> === Mesterséges intelligencia === Bár a mesterséges intelligencia forradalma csak a következő évtizedekben bontakozott ki, a 2000-es években is történtek fontos előrelépések ezen a téren. Az MI ekkor főként kutatási terület maradt, de bizonyos feladatokban már ekkor kimagasló teljesítményt nyújtott. Például 2005-ben egy önvezető autó (Stanley, a Stanford Egyetem járműve) első ízben teljesített sikeresen egy közel 212 km hosszú sivatagi terepversenyt a '''DARPA Grand Challenge''' keretében. Az évtized során fejlődtek a gépi tanulási algoritmusok és a robotika is – többek között ilyen technológiák tették lehetővé az önvezető járművek kísérleteit. A korszak kutatásai megalapozták a későbbi ugrásszerű eredményeket, amelyek a 2010-es években váltak széles körben ismertté. <span id="hardver"></span> === Hardver === A 2000-es években a számítástechnikai hardver teljesítménye tovább nőtt, bár az évtized végére a hagyományos ütem (a Moore-törvény) lassulni kezdett, és előtérbe került a párhuzamos feldolgozás. 2000-ben jelentek meg az első 1 GHz órajelű processzorok (az AMD Athlon és a Pentium III). A számítógépes architektúrák ekkor tértek át fokozatosan a 64 bites címzésre: az AMD 2003-ban piacra dobta az első széles körben elérhető 64 bites PC-processzort (Athlon 64). A magas órajel miatti hőtermelés korlátai miatt a gyártók a többmagos processzorok felé fordultak: 2005-ben az Intel és az AMD egyaránt kiadták első kétmagos processzoraikat (Pentium D, ill. Athlon 64 X2). Fontos iparági váltás volt, hogy az Apple 2005-ben bejelentette: PowerPC helyett Intel processzorokra vált a Mac számítógépeiben; 2006-ban megjelentek az első Intel-alapú Macek is (például a MacBook Pro). A csúcskategóriás számítógépek terén új rekordok születtek: 2000-ben az IBM ASCI White szuperszámítógép 12,3 billió műveletet végzett másodpercenként, ezzel a világ leggyorsabbja lett, az évtized végére pedig az első petaflop (10^15 művelet/s) sebességű rendszer is üzembe állt. A grafikus hardver szintén ugrásszerűen fejlődött. 2004-ben az NVIDIA GeForce 6800 grafikus chip több mint kétszeresére növelte az előző generáció teljesítményét, megközelítve a filmes minőségű, valós idejű megjelenítést. A nagy felbontású optikai adathordozók versenyében a Blu-ray diadalmaskodott a HD DVD felett 2008-ban, ipari szabvánnyá válva. A személyi számítógépek hardvere diverzifikálódott ebben az évtizedben. A hordozható PC-k (laptopok) egyre elterjedtebbé váltak, megjelentek a kisméretű, olcsó '''netbookok''' is (ilyen volt a 2007-ben bemutatott Asus Eee PC mini-laptop). A videojáték-konzolok új generációi jelentek meg, amelyek addig példa nélküli számítási teljesítménnyel és grafikával érkeztek: a Sony PlayStation 2 (2000), a Nintendo GameCube (2001) és a Microsoft Xbox (2001), majd az évtized közepén az Xbox 360 (2005), a PlayStation 3 és a Nintendo Wii (mindkettő 2006). Közben a mobiltelefonok is egyre fejlettebbé váltak: megjelentek az első '''okostelefonok'''. 2000-ben dobták piacra az első, korlátozott internetképes telefont (Ericsson R380, Symbian operációs rendszerrel), 2002-ben pedig az első BlackBerry okostelefont, mely az üzleti e-mailezésben újított. 2007-ben az Apple bemutatta az első iPhone-t, az érintőképernyős, alkalmazásközpontú okostelefont, amely új irányt szabott a mobiltelefon-iparágnak. 2008-ban pedig megjelent az első Android rendszerű telefon is (HTC Dream), ezzel kialakult a következő évtizedeket meghatározó két domináns mobilplatform. <span id="operációs-rendszerek"></span> === Operációs rendszerek === A 2000-es években a főbb asztali operációs rendszerek között továbbra is a Microsoft Windows dominált. 2001-ben jelent meg a Windows XP, amely egységes, megbízható NT-alapú rendszermagot hozott a fogyasztói piacra, és az évtized egyik legnépszerűbb operációs rendszerévé vált. A Windows Vista (2007) az elődjét öt évvel követően került kiadásra, jelentős felhasználói felület-változásokkal, de vegyes fogadtatással. Ezt a Windows 7 követte 2009-ben, amely a Vista hiányosságait orvosolta, és stabil, kedvelt rendszerré vált. Az Apple eközben 2001-ben kiadta a Mac OS X-et (10.0), egy Unix-alapokra épített operációs rendszert, amely leváltotta a korábbi “klasszikus” Mac OS-t. A macOS (OS X) új funkciókat és stabilitást hozott a Macintosh gépekre; az évtized során olyan verziók jelentek meg, mint a Tiger (10.4, 2005) és a Leopard (10.5, 2007), majd 2009-ben a Snow Leopard (10.6) további optimalizációkkal. A nyílt forráskódú operációs rendszerek is erősödtek: a Linux kernel 2.6-os főverziója 2003-ban jelent meg, számos fejlesztéssel, és 2004-ben elérhetővé vált az első Ubuntu Linux disztribúció, mely barátságos felhasználói élményével új közönséget vonzott. A Linux a szerverek és különféle beágyazott rendszerek terén egyre nagyobb teret nyert, bár desktop környezetben részesedése korlátozott maradt. A mobil operációs rendszerek ekkoriban születtek meg. A Symbian OS vált az első okostelefonok de facto platformjává (ezt futotta például az Ericsson R380, az első „okostelefon” 2000-ben), és számos Nokia telefonon is ez működött. 2007-ben az Apple az iPhone-nal együtt bemutatta az iPhone OS-t (későbbi nevén iOS), amely érintőképernyős, alkalmazásközpontú mobil operációs rendszerként forradalmasította a telefonok képességeit. 2008-ban a Google kiadta az Android rendszer első verzióját, valamint megjelent az első Android-alapú okostelefon is (HTC Dream). Ezek az új mobil operációs rendszerek lefektették a modern okostelefon-ökoszisztémák alapjait, és a következő években uralkodó platformokká váltak a mobil piacon. <span id="alkalmazások-és-internetes-szolgáltatások"></span> === Alkalmazások és internetes szolgáltatások === Az internet terjedésével a 2000-es években új alkalmazások és online szolgáltatások váltak széles körben elérhetővé. 2001-ben indult útjára a Wikipedia, egy közösségi szerkesztésű online enciklopédia, amely alapjaiban változtatta meg az ismeretterjesztést. Ugyanebben az évben jelent meg az Apple iTunes szoftvere is, amely az online zenevásárlás és -lejátszás úttörője volt, megágyazva a digitális zenei disztribúció robbanásszerű növekedésének. Az elektronikus levelezésben a Google 2004-ben indította el a Gmail szolgáltatást, mely 1 GB-os ingyenes tárhelyével forradalmat hozott az e-mailben. A 2000-es évek közepére elterjedtek az azonnali üzenetküldők és VoIP alkalmazások is (mint a 2003-ban megjelent Skype), amelyek új kommunikációs lehetőségeket nyitottak. A közösségi hálózatok és a felhasználók által létrehozott tartalmak korszaka is ekkor kezdődött. 2003-ban indult a MySpace közösségi portál, amely hamar népszerűvé vált a fiatalok körében, de a 2004-ben alapított Facebook dinamikus terjeszkedésével átvette a vezető szerepet, 2009-re az Egyesült Államokban már megelőzte a MySpace-t a felhasználók számában. 2005-ben elindult a YouTube videómegosztó oldal, lehetővé téve bárki számára videók globális közreadását; a szolgáltatás sikerét jelzi, hogy a Google már 2006-ban felvásárolta. 2006-ban jelent meg a Twitter, egy új mikroblogging platform, amely 140 karakteres üzenetekben tette lehetővé hírek és információk azonnali megosztását. Ezek az alkalmazások alapjaiban formálták át a közösségi interakciókat és a médiafogyasztást. A webböngészők és internetes keresők területén is verseny bontakozott ki ebben az évtizedben. 2004-ben jelent meg a Mozilla Firefox 1.0, az első sikeres nyílt forráskódú böngésző, mely újraélesztette a böngészők közti versenyt és az Internet Explorer egyeduralmát kezdte megtörni. 2008-ban a Google kiadta a Chrome böngészőt, amely gyorsaságával és egyszerűségével hamar nagy piaci részesedést szerzett, néhány éven belül a világ legelterjedtebb böngészőjévé válva. Közben a keresőszolgáltatások közül a Google (1998-ban indult) a 2000-es években vált dominánssá, háttérbe szorítva vetélytársait, és számos kiegészítő szolgáltatást (térkép, hírek, fordítás stb.) indított. Összességében a 2000-es évek alkalmazásai és online platformjai alapozták meg az információmegosztás, a digitális szórakozás és a közösségi média modern kultúráját. <span id="szoftverfejlesztés-és-nyílt-forráskód"></span> === Szoftverfejlesztés és nyílt forráskód === A 2000-es években a szoftverfejlesztés módszerei és közösségei is jelentősen átalakultak. 2001-ben közzétették az '''Agile Manifestót''', amely az agilis szoftverfejlesztési elveket lefektetve forradalmasította a fejlesztési módszertanokat. Az agilis megközelítés – például a Scrum – egyre inkább felváltotta a hagyományos vízesés-modellt, nem csak az informatikában, hanem más iparágak projektmenedzsmentjében is. Ugyancsak ebben az időszakban erősödött meg a nyílt forráskódú szoftverek mozgalma. Számos szoftver vált hozzáférhetővé nyílt licenc alatt: például a Blender 3D modellező program forráskódját 2002-ben közösségi finanszírozás segítségével publikálták. A nyílt forráskód sikere látható volt a böngészőknél (Firefox), operációs rendszereknél (Linux) és sok egyéb területen. Ugyanakkor megjelentek a jogi viták is: 2003-ban a SCO pert indított az IBM ellen arra hivatkozva, hogy a Linux forráskódja jogvédett UNIX-kódot tartalmaz – ez a per évekig elhúzódott, ráirányítva a figyelmet az open source szoftverek licencelési kérdéseire. A programozási technológiák terén a webalkalmazások és a szolgáltatás-orientált architektúrák térnyerése volt jellemző. Új szkriptnyelvek és keretrendszerek (például a PHP alapú tartalomkezelők, vagy a JavaScript AJAX technikája 2005-től) jelentek meg a dinamikus weboldalak kiszolgálására. A vállalati szoftverfejlesztésben a Java és a 2002-ben megjelent .NET platform (C# nyelvvel) dominánssá vált, míg a dinamikus nyelvek (Python, Ruby stb.) is egyre népszerűbbek lettek bizonyos feladatkörökben. A szoftverek terjedése és az internet összekapcsoltsága új biztonsági kihívásokat is hozott: a 2000-ben felbukkanó “ILOVEYOU” számítógépes féreg és a későbbi vírusjárványok milliószám fertőzték a PC-ket világszerte, ami előtérbe állította az IT-biztonság és antivírus megoldások fontosságát. Összességében a 2000-es évek megalapozták a modern szoftverfejlesztési ökoszisztémát, amelyben az agilis módszerek, a nyílt forráskód és az internetközpontú alkalmazások kulcsszerepet kapnak. <span id="közösségi-hatás"></span> === Közösségi hatás === A számítástechnika a 2000-es években a gazdaságra és a mindennapi életre is egyre nagyobb hatást gyakorolt. Az évtized elején lezajlott a sokak által rettegett Y2K („millennium bug”) probléma – a globális erőfeszítéseknek köszönhetően komolyabb üzemzavarok nélkül. Ugyanakkor 2000-ben kipukkadt a dotkom lufi, ami számos technológiai cég csődjét okozta és átmeneti megtorpanást jelentett az internetgazdaságban. A visszaesést azonban gyors növekedés követte: az évtized közepére az online iparágak megerősödtek, és új tech-óriások emelkedtek fel. A Google például a 2000-es években vált a világ vezető keresőjévé és online hirdetési vállalatává; az Amazon és az eBay forgalma az e-kereskedelem robbanásával sokszorosára nőtt. Az Apple a 2000-es években tért vissza a csúcsra az iPod (2001) és az iPhone (2007) sikere révén. 2008-ban a globális gazdasági válság ugyan minden ágazatot érintett, de az informatikai szektor a visszaesést viszonylag jól átvészelte, és az évtized végére a technológia ismét a gazdasági innováció motorjává vált. A társadalomban is mélyreható változásokat indított el a technológia terjedése. Az internetpenetráció ugrásszerűen nőtt ebben az időszakban: 2000-ben a világ népességének alig néhány százaléka rendelkezett internet-hozzáféréssel, 2010-re ez az arány megközelítette a 30%-ot. A mindennapi kommunikáció átalakult: az e-mail, az SMS és az online chat a levelezés és telefonálás mellé zárkózott fel, a közösségi hálózatok (mint a MySpace és Facebook) pedig új fórumot adtak az ismerősökkel való kapcsolattartásra. A médiafogyasztás is változott – egyre többen olvastak híreket online, néztek videókat a YouTube-on, vagy hallgattak zenét digitális formában. Az „információs társadalom” fogalma ekkor vált kézzelfoghatóvá: soha korábban nem volt ennyi ember számára ennyire hozzáférhető a tudás és az információ. Ugyanakkor megjelentek az új kihívások is, például a digitális függőség első jelei, valamint a '''digitális szakadék''' a társadalom különböző rétegei és a világ régiói között – a gyors technológiai fejlődés nyertesei elsősorban a fejlett országok lettek, míg sok fejlődő térség lemaradása nőtt. Összességében a 2000-es évekre a számítástechnika olyan nélkülözhetetlen infrastruktúrává vált, mint az elektromosság: az élet szinte minden területére behatolt, megalapozva a 21. század digitális korszakát. <span id="es-évek-1"></span> == 2010-es évek == <span id="mesterséges-intelligencia-1"></span> === Mesterséges intelligencia === A 2010-es években a mesterséges intelligencia terén korábban csak kutatási szinten létező technikák áttörtek a gyakorlati alkalmazásokba. 2011-ben az IBM '''Watson''' nevű rendszere megnyerte az amerikai Jeopardy! televíziós kvízjátékot, demonstrálva a gépi természetesnyelv-feldolgozás képességeit. 2012-ben a mély neurális hálózatok először értek el kiemelkedő eredményeket látásfelismerési feladatokban (pl. a ImageNet versenyben), ami elindította a “deep learning” forradalmat. Az évtized közepére az MI látványos eredményeket produkált a játékokban: 2016-ban a Google DeepMind által fejlesztett AlphaGo program legyőzte a világ egyik legjobb gojátékosát, Lee Sedolt, amely mérföldkőnek számított a gépi tanulásban. A mesterséges intelligenciát egyre több területen kezdték alkalmazni: az okostelefonokban megjelentek a személyi asszisztensek (Apple Siri, 2011; Amazon Alexa, 2014; Google Assistant, 2016), a gépi fordítás és beszédfelismerés minősége ugrásszerűen javult, és az önvezető autók fejlesztése is felgyorsult. A 2010-es évek végére az MI olyan képességeket mutatott (például képek automatikus felismerése, emberi szintű beszélgetés bizonyos területeken), amelyek előrevetítették a technológia még szélesebb körű alkalmazását a következő évtizedben. <span id="hardver-1"></span> === Hardver === A 2010-es években a számítástechnikai eszközök minden korábbinál elterjedtebbé és sokoldalúbbá váltak. Az okostelefonok uralkodó platformmá nőtték ki magukat: az évtized elején az Apple iPhone és a Google Android alapú készülékek generációi gyors ütemben fejlődtek (nagyobb, nagyfelbontású érintőképernyők, erős többmagos mobilprocesszorok, egyre jobb kamerák). 2010-ben az Apple bemutatta az iPad táblagépet, új kategóriát teremtve a hordozható eszközök piacán. A PC-k hardverében is folytatódott a fejlődés: a processzorok magonkénti teljesítménye lassabb ütemben nőtt, de a magok száma tovább emelkedett, és megjelentek a sokmagos (8+ mag) CPU-k is a fogyasztói piacon (pl. 2017-től az AMD Ryzen széria). A grafikus processzorok (GPU-k) kulcsszerepet kaptak a párhuzamos számítási feladatokban, különösen a mesterséges intelligencia számításokban – az NVIDIA és az AMD egyre nagyobb és hatékonyabb GPU-kat dobott piacra. A félvezetőgyártás a 2010-es évek végére a 10 nm alatti csíkszélességet is elérte, bár a fizikai korlátok miatt a Moore-törvény üteme lassult. Az évtized során számos új hardvertechnológia jelent meg. 2014-ben bemutatkozott a nyílt forrású '''RISC-V''' utasításkészlet-architektúra, amely lehetővé tette testreszabható processzorok fejlesztését. A memória és háttértár kapacitások nagyságrendekkel nőttek: 2010-re általánossá váltak a gigabájtos memóriák és több száz gigabájtos – később terabájtos – merevlemezek, valamint a félvezető alapú SSD-k is egyre inkább felváltották a hagyományos winchestereket (2016-ra megjelentek az első 10+ terabájtos meghajtók). A szuperszámítógépek terén Kína és az Egyesült Államok versengett az első helyért: 2011-ben átlépték a 10 petaflops határt, 2018-ra pedig már 200 petaflops feletti gépek vezették a ranglistát. 2019-ben a Google bejelentette, hogy kvantumszámítógépe elérte a „kvantumfölényt” egy specifikus feladatban, jelezve a kvantumszámítások terén elért előrelépést. Ezen innovációk révén a 2010-es évek végére a hardver lehetővé tette korábban elképzelhetetlen komplexitású számítások elvégzését, az eszközök pedig mindennapjaink részévé váltak (okosórák, fitnesz-trackerek, okoshangszórók formájában is). <span id="operációs-rendszerek-1"></span> === Operációs rendszerek === A 2010-es években az operációs rendszerek terén a Microsoft, az Apple és a mobilplatformok fejlődése volt meghatározó. A Microsoft 2012-ben jelentette meg a radikálisan új felületű Windows 8-at, amely az érintőképernyős eszközökhöz igazodott, ám vegyes fogadtatásban részesült. 2015-ben kijött a Windows 10, amely visszahozott sok hagyományos elemet és egységes platformot kínált PC-kre és tabletekre egyaránt – a Microsoft ezt “szolgáltatásként” fejlesztette tovább folyamatos frissítésekkel. Az Apple macOS rendszere évente frissült: olyan verziók jelentek meg, mint a macOS Sierra, High Sierra, majd 2019-ben a macOS Catalina, amelyek fokozatos fejlesztésekkel bővítették az Apple ökoszisztémát. Külön fontos lépés volt, hogy az Apple 2011-ben bemutatta az iCloud szolgáltatást, integrálva az eszközök közti adat-szinkronizációt az OS-be. Mobil fronton a Google Android és az Apple iOS dominanciája egyértelművé vált. Az Android számos verzión keresztül (Gingerbread-től a Pie-ig) fejlődött a 2010-es években, és nyílt forráskódú jellege miatt a világ legelterjedtebb operációs rendszerévé vált okostelefonokon. Az iOS közben megtartotta erős pozícióját a prémium szegmensben, évente megújuló verziókkal (pl. iOS 7 teljes dizájnváltása 2013-ban). A korábbi mobil OS-ek – mint a BlackBerry OS és a Windows Phone (2010-ben indult) – nem tudták tartani a lépést, a BlackBerry 2016-ra átállt Androidra, a Windows Phone pedig 2017-ben gyakorlatilag megszűnt. Az új eszközkategóriák (okosórák, okostévék, autós fedélzeti rendszerek) saját specializált operációs rendszerekkel jelentek meg (pl. Android Wear, Apple watchOS, Samsung Tizen), tovább szélesítve az OS-ek családját. Emellett a nyílt forrású Linux továbbra is kulcsszerepet játszott a szervereken és felhőszolgáltatásokban, a containerizáció (Docker) és az orchestration (Kubernetes) pedig újfajta “operációs rendszer-szintű” réteget adtak a felhő infrastruktúrához. <span id="alkalmazások-és-szolgáltatások"></span> === Alkalmazások és szolgáltatások === A 2010-es években az internetes alkalmazások és digitális szolgáltatások minden területen előretörtek. A közösségi média globálisan uralkodó kommunikációs platformmá vált: a Facebook felhasználóinak száma 2012-re átlépte az egymilliárdot, majd az évtized végére a 2 milliárdot is meghaladta, részben az olyan felvásárlások révén, mint az Instagram (2012) és a WhatsApp (2014). A Twitter a hírek és közéleti diskurzus fontos csatornájává vált világszerte. Új szereplők is megjelentek: 2011-ben indult a Snapchat, amely az eltűnő üzenetekkel új trendet teremtett, a fiatalabb generációk körében pedig a TikTok (2016-tól nemzetközileg) rövid videós platformja robbant be az évtized végén. A fejlődő világban – különösen Kínában – saját ökoszisztémák nőttek fel: a WeChat például egyetlen alkalmazásban egyesítette az üzenetküldést, közösségi médiát és fizetési szolgáltatásokat. Az online médiafogyasztás is alapjaiban változott meg. A videó-streaming lett a szórakoztatás egyik fő formája: a Netflix átalakult DVD-kölcsönzőből globális streaming platformmá, saját tartalomgyártással, a YouTube pedig a legnagyobb nyilvános videóplatform maradt, ahol már milliárdos nézettségű videók születtek. A zeneiparban a streaming modellek (Spotify, Apple Music) váltak dominánssá, háttérbe szorítva a letöltést és a fizikai adathordozókat. Az okostelefonos alkalmazásboltok (Apple App Store, Google Play) több millió alkalmazást kínáltak – a mindennapi tevékenységek (ételrendelés, navigáció, bankolás, társkeresés stb.) egyre inkább mobilappokon keresztül zajlottak. Az ún. “megosztáson alapuló gazdaság” is a technológiai platformokra épült: az Uber és társai megreformálták a városi személyszállítást, az Airbnb pedig a szálláskiadást alakította át globálisan. Emellett az online játékok és e-sportok hatalmas iparággá fejlődtek (pl. a League of Legends és a Dota 2 nemzetközi bajnokságai). A 2010-es évek végére a digitális szolgáltatások az élet minden területén jelen voltak, a hagyományos ágazatok (kiskereskedelem, média, közlekedés, pénzügyek) működését is gyökeresen átalakítva. <span id="szoftverfejlesztés-és-infrastruktúra"></span> === Szoftverfejlesztés és infrastruktúra === A szoftveriparban a 2010-es évek kulcsszavai a „felhő” és a „big data” lettek. A vállalatok tömegesen tértek át a felhőalapú infrastruktúrákra – az Amazon Web Services, a Microsoft Azure és a Google Cloud Platform szolgáltatásai lehetővé tették, hogy rugalmasan, igény szerint skálázhatóan futtassák alkalmazásaikat a vállalatok. A fejlesztési és üzemeltetési folyamatok összeolvadtak a DevOps szemléletben, és elterjedtek a konténertechnológiák: a Docker (2013) konténerei és a Kubernetes (2014) orkesztrációs rendszere szabvánnyá váltak a felhős alkalmazások telepítésében. Az adatelemzés és gépi tanulás terén új eszközök jelentek meg: a Hadoop és Spark keretrendszerek lehetővé tették a hatalmas adathalmazok (big data) feldolgozását, míg a TensorFlow (2015) és más gépi tanulási könyvtárak révén a mesterséges intelligencia fejlesztése széles körben elterjedt. A programozási nyelvek között is volt mozgás: az Apple 2014-ben bemutatta a Swift nyelvet a biztonságosabb és modernebb iOS/macOS-fejlesztéshez, a Mozilla által fejlesztett Rust (stabil 2015-től) pedig a memória-biztonságot helyezte előtérbe a rendszerszoftverek terén. A JavaScript nyelv a Node.js platform (2009) és a front-end keretrendszerek révén full-stack fejlesztési eszközzé vált. Az évtized során egyre hangsúlyosabb lett az informatikai biztonság. Számos nagy horderejű adatvesztés és kibertámadás történt: 2013-ban derült fény arra, hogy az amerikai NSA tömeges megfigyeléseket végzett az interneten (Edward Snowden kiszivárogtatásai), ami világszerte aggodalmat keltett a magánszféra védelmét illetően. 2017-ben a WannaCry zsarolóvírus világszerte számítógépek százezreit fertőzte meg, rávilágítva a sebezhető, frissítetlen rendszerek veszélyeire. 2018 elején nyilvánosságra kerültek a Meltdown és Spectre nevű hardver-sebezhetőségek, amelyek szinte minden modern processzort érintettek, és sürgős szoftveres javításokat követeltek a rendszerek védelme érdekében. A GDPR európai uniós adatvédelmi rendelet 2018-ban lépett életbe, szigorúbb szabályokat hozva a személyes adatok kezelésére. A szoftverfejlesztés és üzemeltetés világában mindezek hatására alapvető követelménnyé vált a biztonságos kódolás, a gyors frissítési képesség és a folyamatos monitorozás, miközben a fejlesztők soha nem látott eszköztárral dolgozhattak a felhő és az open source révén. <span id="közösségi-hatás-1"></span> === Közösségi hatás === A 2010-es években a digitális technológia hatása a társadalomra még nyilvánvalóbbá vált. A közösségi média nemcsak a személyes kapcsolattartást, hanem a politikát és a társadalmi mozgalmakat is befolyásolta: 2011-ben az '''Arab tavasz''' eseményei során a Facebookot és a Twittert a tüntetések szervezésére használták, míg a későbbi években is számos tiltakozás és kampány (pl. a #MeToo mozgalom 2017-ben) az online platformokon szerveződött. Ugyanakkor egyre nagyobb aggodalmat keltett a dezinformáció terjedése és az „echo chamber” jelenség – különösen a 2016-os amerikai elnökválasztás kapcsán merült fel a vád, hogy a közösségi oldalak elősegítik az álhírek terjedését. 2018-ban a Cambridge Analytica botrány rámutatott, hogy a Facebook felhasználói adatokat politikai célokra is fel lehet használni, ami globális vitát indított a személyes adatok védelméről. A kormányzati megfigyelés is a figyelem középpontjába került: Edward Snowden 2013-as leleplezései nyomán világossá vált, hogy a nemzetbiztonsági szervek kiterjedt elektronikus megfigyelést folytatnak. Mindezek hatására szigorúbb szabályozás született (az EU GDPR rendelete 2018-ban lépett életbe), és nőtt az igény az erősebb titkosítás és a magánszféra védelme iránt. A mindennapi élet és kultúra is átalakult a 2010-es években a technológia által. Az okostelefon folyamatos jelenléte megváltoztatta a munka és a magánélet közötti határvonalat, sokan napi szinten órákat töltöttek a képernyők előtt. Megjelent a '''digitális függőség''' fogalma, valamint a technológia mentális egészségre gyakorolt hatásainak vizsgálata. Ugyanakkor a digitális gazdaság kényelmet és új lehetőségeket hozott: az online vásárlás (e-commerce) az egész világon elterjedt, a streaming és on-demand szolgáltatások testre szabták a médiafogyasztást, az okoseszközök (pl. fitnesszkarkötők) pedig az egészségtudatos életmód részévé váltak. A munka világában megjelent a távmunka és a szabadúszó gig-gazdaság a digitális platformok révén, bár ez felvetette a munkavállalói jogok és a munkahelyi biztonság kérdéseit. A világ internet-használóinak aránya az évtized végére már meghaladta az 50%-ot, de a digitális szakadék tovább élt: a vidéki és szegény térségek lemaradása még mindig kihívást jelentett. Összességében a 2010-es évekre a digitalizáció a társadalom alapvető szövetét is átszőtte – az információ, a kommunikáció és a gazdaság alapvetően online térbe helyeződött át, új előnyöket és új problémákat egyaránt szülve. <span id="as-évek"></span> == 2020-as évek == <span id="mesterséges-intelligencia-2"></span> === Mesterséges intelligencia === A 2020-as évek elején a mesterséges intelligencia ugrásszerű fejlődése a széles nyilvánosság számára is nyilvánvalóvá vált. 2020-ban megjelent az OpenAI '''GPT-3''' nyelvi modellje, amely addig soha nem látott minőségben volt képes összefüggő szövegeket generálni. 2022 végén hatalmas visszhangot váltott ki a ChatGPT nevű chatbot, amely a GPT-3.5 modellen alapult és párbeszédes formában nyújtott az emberihez közeli válaszokat – néhány hónap alatt több mint 100 millió felhasználó próbálta ki világszerte. 2023-ban az OpenAI bemutatta a még fejlettebb GPT-4 modellt, ami tovább fokozta az MI körüli érdeklődést. A generatív MI nemcsak szövegben, hanem a képi területen is áttörést ért el: 2022-ben nyilvánossá váltak olyan programok (DALL-E 2, Stable Diffusion, Midjourney), amelyek szöveges leírás alapján képesek magas minőségű képeket alkotni. Egy ilyen mesterségesen generált kép meg is nyert egy művészeti versenyt 2022-ben, ami vitát indított a digitális művészet jövőjéről. Ugyanebben az évben a DeepMind AlphaFold rendszere előrejelezte gyakorlatilag az összes ismert fehérje térbeli szerkezetét, óriási erőforrást teremtve a biológiában. Az MI alkalmazásai a 2020-as években már mindennapossá váltak: ajánlórendszerek szűrik a közösségi média és streaming tartalmakat, az okostelefonok kamerái MI-algoritmusokkal javítják a fotókat, a fordítóprogramok valós időben működnek, és a navigációs alkalmazások valós idejű forgalmi adatokat használnak fel. Ugyanakkor az MI fejlődése egyre több aggodalmat is felvetett. A társadalomban vita bontakozott ki arról, hogy a mesterséges intelligencia miként hat a munkaerőpiacra (számos rutinfeladat automatizálhatóvá vált), az oktatásra (a chatbotok képesek megírni esszéket a diákok helyett) és az információ hitelességére (MI által generált álhírek és deepfake videók jelenhetnek meg). 2023-ban több szakértő nyílt levélben figyelmeztetett az esetleges túlságosan fejlett MI kockázataira, és szabályozás kidolgozását sürgette. Mindezek alapján a 2020-as évekre a mesterséges intelligencia fejlődése egyszerre kínált páratlan lehetőségeket és új kihívásokat, amelyek megoldása a következő évek feladata lesz. <span id="hardver-2"></span> === Hardver === A 2020-as évek elején a számítástechnikai hardvert elsősorban a globális események és a specializált igények formálták. A 2020-ban kitört COVID-19 világjárvány egyszerre növelte a digitális eszközök iránti keresletet és akadozást okozott az ellátási láncokban, ami súlyos félvezető-hiányhoz vezetett 2021-ben – ez rávilágított a modern gazdaság függésére a chipgyártástól. Időközben a személyi számítógépek piacán fontos váltás történt: az Apple 2020-ban piacra dobta első saját tervezésű, ARM-alapú számítógépes chipjét (Apple M1), amely kiemelkedő teljesítményt nyújtott alacsony fogyasztás mellett, jelezve az ARM architektúra életképességét a PC-ken is. A PC-processzorok terén az AMD és az Intel versenye folytatódott; az Intel 2021-ben mutatta be a hibrid magstruktúrájú Alder Lake architektúrát, míg az AMD a Zen 3 és Zen 4 processzorokkal erősítette pozícióját. A grafikus kártyák piacát nagyban befolyásolta a kriptovaluta-bányászat fellendülése, majd visszaesése: 2020-21-ben az NVIDIA és AMD GPU-k hiánycikké váltak a bányászok kereslete miatt, 2022-re azonban a kriptopiac összeomlása után normalizálódott a kínálat. A telekommunikációban a 2020-as évek elején széles körben bevezették az 5G mobilhálózatokat, lehetővé téve a gigabites sebességű vezeték nélküli adatátvitelt és új alkalmazásokat (IoT, önvezető autók kommunikációja). Az IoT-eszközök száma exponenciálisan nőtt: okosotthon-eszközök, szenzorhálózatok, ipari IoT rendszerek terjedtek el, amelyek rengeteg adatot gyűjtenek valós időben. A szuperszámítógépek versenyében mérföldkőhöz érkeztünk: 2022-ben az amerikai Frontier rendszer lett az első, amely átlépte az exaflops (10^18 művelet/másodperc) teljesítményt, ezzel új korszakot nyitva a nagy teljesítményű számításban. A kvantumszámítógépek is tovább fejlődtek: a qubit-ek száma egyre nő a kísérleti rendszerekben (2021-ben az IBM egy 127 qubit-es processzort jelentett be), bár a kvantumeszközök gyakorlati alkalmazása még korlátozott. Az évtized elején megjelentek az első önvezető taxik kísérleti jelleggel egyes városokban, illetve a magánűrhajózás fellendülése (SpaceX, Blue Origin) is kihasználta a fejlett számítógépes rendszereket. Összességében a hardver terén a 2020-as években a teljesítmény növelése mellett a megbízhatóság és az ellátási stabilitás kérdései is előtérbe kerültek, miközben egyre több speciális célhardver (MI-gyorsítók, kvantumchipek) jelent meg a hagyományos CPU/GPU páros kiegészítéseként. <span id="operációs-rendszerek-2"></span> === Operációs rendszerek === A 2020-as évek elején az operációs rendszerek terén a változások inkább evolúciósak, semmint forradalmiak voltak. A Microsoft 2021-ben adta ki a Windows 11-et, amely modernizált felhasználói felületet hozott és magasabb hardverkövetelményeket támasztott (például csak biztonsági chipet tartalmazó PC-ken támogatott) – ezzel a cég gyakorlatilag lezárta a Windows 10 „örök Windows” korszakát. Az Apple folytatta éves macOS frissítési ciklusát, immár natív támogatással az új ARM alapú Apple Silicon chipekre; a macOS Big Sur (2020) és utódai már optimalizáltan futottak az M1/M2 chipeken. A desktop Linux továbbra is egy stabil, de kisebbségi szereplő maradt az asztali gépeken, viszont a felhőben és szervereken domináns pozícióban volt. A mobil operációs rendszerek – Android és iOS – uralma megkérdőjelezhetetlen maradt. Az Android 2020-as években kiadott verziói (11, 12, 13) tovább finomították a rendszer teljesítményét és biztonságát, míg az iOS is évente frissült új funkciókkal (pl. widgetek, értesítési reform). A Huawei amerikai szankciók miatti kiszorulása nyomán a cég 2021-ben saját HarmonyOS rendszerét kezdte el fejleszteni, de ez elsősorban Kínában terjedt. Az okoseszközök (óra, TV, autó) világában az Android és Linux alapú beágyazott rendszerek domináltak. Az operációs rendszerek frontján tehát a 2020-as évek a konvergencia jegyében teltek: minden platform igyekezett hasonló felhasználói élményt nyújtani, széles ökoszisztémákkal (alkalmazásboltok, felhő-szolgáltatások) kiegészítve. A virtualizáció és a konténerezés továbbra is kulcsfontosságú volt a szerveroldalon, de a végfelhasználó ezt már nagyrészt láthatatlan felhős háttérszolgáltatásként érzékelte. <span id="alkalmazások-és-szolgáltatások-1"></span> === Alkalmazások és szolgáltatások === A 2020-as évek elejét alapvetően meghatározta a COVID-19 járvány, ami felgyorsította számos digitális szolgáltatás térnyerését. 2020-ban és 2021-ben emberek százmilliói kényszerültek otthoni munkavégzésre és tanulásra, ami az olyan videokonferencia-platformok sikeréhez vezetett, mint a Zoom, a Microsoft Teams vagy a Google Meet. A távmunka és hibrid munkavégzés a pandémia lecsengése után is sok helyen megmaradt, így ezek az alkalmazások hosszú távon is beépültek a vállalati működésbe. Az online kereskedelem szintén rekord növekedést ért el a lezárások alatt, az élelmiszer-házhozszállító és e-kereskedelmi szolgáltatások (pl. Instacart, Amazon) kritikus infrastruktúraként működtek. A közösségi média ökoszisztémája is változott: a TikTok 2020-ra a világ legletöltöttebb alkalmazásává vált, és meghonosította a rövid, pörgős videók trendjét, amelyre a konkurensek (Instagram Reels, YouTube Shorts) is reagáltak. A Facebook (Meta) 2021-ben nagy lendülettel hirdette meg a “metaverzum” vízióját – át is nevezte magát Meta Platforms-nak –, és erőforrásokat fektetett a virtuális valóság alapú közösségi terek fejlesztésébe, de a metaverzum koncepció egyelőre nem váltotta be a hozzá fűzött reményeket. Eközben a digitális szórakoztatás más formái virágoztak: a videojáték-ipar bevétele meghaladta a filmiparét, az e-sport események és streamingek (pl. Twitch) hatalmas közönséget vonzottak. A hagyományos mozik és tévézés népszerűsége csökkent, miközben a streaming-szolgáltatók (Netflix, Disney+, HBO Max stb.) egymással versengve gyártották az exkluzív tartalmakat a nézők megtartásáért. Az évtized elején lezajlott egy kriptovaluta- és blokklánc-őrület is. 2021-ben a Bitcoin árfolyama soha nem látott magasságba emelkedett, és sorra jelentek meg a decentralizált pénzügyi (DeFi) alkalmazások, valamint a NFT-k (nem helyettesíthető tokenek) a digitális műtárgypiacon. 2022-re azonban a kriptovaluta-piac összeomlott: több nagy szolgáltató (pl. FTX tőzsde) csődbe ment, a tokenek értéke zuhant, és sok befektető veszteségeket szenvedett el. Mindez valamelyest hűtötte a “Web3” néven emlegetett, blokklánc-alapú internet vízióját. Ugyanakkor a digitális fizetési megoldások (mobilfizetés, fintech alkalmazások) mainstreammé váltak: a járvány is hozzájárult a készpénzmentes tranzakciók terjedéséhez. Összességében a 2020-as évek első fele az alkalmazások terén a virtuális kapcsolattartás, a streaming és a digitális gazdaság további térnyerését hozta, miközben új hype-ok születtek és buktak el a tech világ gyors ciklusában. <span id="szoftverfejlesztés-és-infrastruktúra-1"></span> === Szoftverfejlesztés és infrastruktúra === A 2020-as évek elején a szoftveres infrastruktúra további felhősödése és automatizálása zajlott. A nagy felhőszolgáltatók (AWS, Azure, Google Cloud) piaci részesedése tovább nőtt, bár egyre több szervezet törekedett multi-cloud vagy hibrid megoldásokra az elosztott kockázat érdekében. Az alkalmazások üzemeltetésében az ún. „felhő-natív” megközelítés vált általánossá: konténerekben és mikroszolgáltatásokban gondolkodtak a fejlesztők, és az infrastruktúra-szolgáltatások (Infrastructure as Code) automatizáltan, kóddal vezérelve működtek. A 2020-as évek elején a fejlesztői eszköztárba belépett a mesterséges intelligencia is: 2021-ben elindult a GitHub Copilot, amely képes kódrészleteket javasolni a fejlesztőknek a mesterséges intelligencia segítségével, 2022–2023-ban pedig a ChatGPT-hez hasonló modelleket már komplex programkód generálására is használták. Ez felgyorsíthatja a fejlesztést, de felveti a kérdést a kódminőség és a szerzői jog kapcsán is, hiszen az MI sok esetben nyílt forráskódú projektek kódján tanult. A szoftverbiztonság továbbra is kritikus kérdés maradt. 2020-ban egy nagyszabású supply chain-támadás derült ki (a SolarWinds nevű vállalat szoftverfrissítését feltörve kormányzati rendszerekbe jutottak be hekkerek), 2021-ben pedig a Log4Shell sebezhetőség rengeteg szervert érintett világszerte, bizonyítva hogy egy apró nyílt forrású komponens hibája is globális krízist okozhat. Mindez felgyorsította az ellátási lánc biztonságának vizsgálatát és az úgynevezett nulladik napi (zero-trust) biztonsági modellek terjedését. A nemzetek kormányai is egyre jobban figyeltek a szoftveriparra: az USA 2022-ben elfogadta a CHIPS és Science Act-et a félvezetőgyártás támogatására, az EU pedig kidolgozta az AI Act tervezetét a mesterséges intelligencia szabályozására. A szoftverfejlesztés kultúráját eközben a „távolról együttműködés” jellemezte: a fejlesztőcsapatok sokszor földrajzilag szétszórtan, online eszközökkel együttműködve dolgoztak. A 2022–2023-ban bekövetkező nagyszabású tech-leépítések (több nagyvállalat egyszerre több ezer mérnököt bocsátott el) rámutattak, hogy a szektor sem immunis a gazdasági ciklusokra. Összességében a szoftveripar a 2020-as években is a rugalmasságot, automatizációt és biztonságot helyezte előtérbe az egyre összetettebb rendszerek kiszolgálása érdekében. <span id="közösségi-hatás-2"></span> === Közösségi hatás === A 2020-as évek elejét a COVID-19 pandémia határozta meg, amely példátlan módon tette próbára a világ társadalmait – és a technológia kulcsszerepet játszott a válaszadásban. Az emberek tömegesen szorultak a digitális térbe: a munkahelyi meetingektől az iskolai oktatásig, sőt a baráti találkozókig sok minden átkerült az online platformokra. Ez felgyorsította a digitalizációt olyan területeken is, ahol korábban lassabb volt (pl. telemedicina, e-kormányzat). Ugyanakkor rámutatott a társadalmi egyenlőtlenségekre is: akinek nem volt stabil internetkapcsolata vagy digitális eszköze, az lemaradt – a digitális szakadék problémája így új megvilágításba került. A pandémia alatt az álhírek és összeesküvés-elméletek is virálisan terjedtek az interneten (pl. vakcina-ellenes mozgalmak), ami tovább fokozta a hiteles tájékoztatás kihívását. A geopolitikában is megjelent a technológiai vetélkedés. Az USA és Kína között technológiai hidegháború bontakozott ki: az Egyesült Államok korlátozásokat vezetett be a kínai cégek (pl. Huawei, TikTok) ellen adatbiztonsági és nemzetbiztonsági aggályokra hivatkozva, valamint exporttilalmat rendelt el a csúcstechnológiájú chipekre és berendezésekre (2022). Kína ezzel párhuzamosan igyekezett saját önellátását erősíteni a félvezetők és szoftverek terén. 2022-ben kitört az orosz–ukrán háború, ahol a kibertámadások, a műholdas internetszolgáltatások (SpaceX Starlink) és a közösségi média narratívaháborúja mind a konfliktus részévé váltak. A technológiai nagyvállalatok erejét továbbra is vitatták: az EU-ban életbe lépett a Digitális Szolgáltatások és Digitális Piacok törvénye (DSA, DMA), hogy szabályozza a „Big Tech” hatalmát, és világszerte vizsgálták a Google, Amazon, Facebook monopóliumait. Mindeközben a mindennapokban az emberek életét egyre inkább átszőtte a technológia. A távmunkának és rugalmasságnak köszönhetően felértékelődött az életminőség és a vidékre költözés lehetősége, bár ez nem mindenhol valósult meg. Az okoseszközök és alkalmazások rengeteg adatot gyűjtöttek a felhasználókról, ami egyrészt személyre szabott élményeket nyújtott, másrészt folyamatos megfigyelés érzését kelthette. A mesterséges intelligencia 2023-as robbanása ismét aggodalmat keltett: sokan tartanak attól, hogy a generatív MI elmosta a valós és hamis tartalmak határát, illetve bizonyos szakmák (pl. ügyfélszolgálat, tartalomgyártás) munkahelyeit fenyegetheti. Ugyanakkor az innováció reményekre is okot ad: az MI-től orvosi áttöréseket, az automatizálástól pedig veszélyes vagy monoton munkák kiváltását várják. A 2020-as évek elejére a társadalom nagy kérdése az lett, hogyan lehet a technológia előnyeit maximalizálni úgy, hogy közben kontroll alatt tartjuk a káros hatásokat – legyen szó az egyéni mentális egészségről, a demokrácia védelméről vagy a nemzetbiztonságról. {{engl}} {{Timeline History of Computing}} svosoysfhn1ooqbkg8gaztlbvei3vw9 0 804394 3523808 3496060 2026-07-10T19:46:27Z Neriassel 28746 eltévedt wikipédára való tartalom jelölése törlésre 3523808 wikitext text/x-wiki {{azonnali|nem szótárcikk, ez a wikipédára való |[[Szerkesztő:Neriassel|Neriassel]] ([[Szerkesztővita:Neriassel|vita]]) 2026. július 10., 21:46 (CEST)}} [[File:Glen_Beck_and_Betty_Snyder_program_the_ENIAC_in_building_328_at_the_Ballistic_Research_Laboratory.jpg|thumb|ENIAC]] {{hunfn}} # {{label|hu|informatika}} <span id="a-számítástechnika-története"></span> = A számítástechnika története = <span id="es-évek-az-elektronikus-számítógépek-hajnala"></span> == 1940-es évek – Az elektronikus számítógépek hajnala == ''Az ENIAC számítógép (1946) egyike volt az első teljesen elektronikus, digitális számítógépeknek, amelyet elsősorban ballisztikus számításokra használtak az amerikai hadseregben.'' <span id="találmányok-és-első-használatok"></span> === Találmányok és első használatok === A második világháború időszakában jelentek meg az első '''programozható számítógépek'''. 1941-ben a német mérnök, '''Konrad Zuse''' megépítette a ''Z3'' gépet, amely a világ első működő programvezérelt számítógépe volt – bináris számrendszert alkalmazott, lebegőpontos számábrázolással és 64 szó kapacitású memóriával. Ugyanekkor az Egyesült Államokban '''John Atanasoff''' és '''Clifford Berry''' kifejlesztették az ''Atanasoff–Berry Computer (ABC)'' gépet, amely az első elektronikus számológép volt lineáris egyenletrendszerek megoldására. Az ABC különlegessége az volt, hogy kondenzátor-alapú, regeneratív memóriát használt (ez tekinthető az első ''RAM'' megvalósításnak). A titkosítás terén az Egyesült Királyságban, a Bletchley Parkban, '''Max Newman''' és csapata 1943-ban üzembe helyezte a ''Heath Robinson'' nevű elektromechanikus számolóművet, amely a náci rejtjelek megfejtését segítette. Ezt követte 1943 végén a '''Tommy Flowers''' által épített ''Colossus'' számítógép, amely az első teljesen elektronikus, digitális számítógép volt – igaz, programozhatósága korlátozott és kifejezetten a Lorenz-kód feltörésére tervezték. A Colossus 1500 elektroncsövet tartalmazott és másodpercenként ~25 000 karakter feldolgozására volt képes, jelentősen felgyorsítva a kódfeltörést. Mivel ez a munka szigorúan titkos volt, a Colossus létezését évtizedekig homály fedte, így nem befolyásolta az Egyesült Államokban zajló fejlesztéseket. 1946-ban az USA-ban bemutatták az ''ENIAC'' gépet (Electronic Numerical Integrator and Computer), amely az első nagyszabású, általános célú, teljesen elektronikus számítógép volt. Az ENIAC 18 000 elektroncsővel működött, 30 tonnát nyomott és 160 kW energiát fogyasztott. Összetett ballisztikai számításokat és a hidrogénbomba-fejlesztéshez kapcsolódó numerikus feladatokat végzett, nagyjából 5000 művelet/s sebességgel. Programozása kezdetben kézi átkötésekkel és kapcsolóállításokkal történt – tehát nem volt még tárolt program elve szerint működő gép. 1948-ban azonban a '''Manchester Baby''' (Small-Scale Experimental Machine) az Egyesült Királyságban elsőként futtatott programot egy ''tárolt programú számítógépként'', a memória mátrixában eltárolva mind az adatokat, mind az utasításokat. 1949-re pedig '''Maurice Wilkes''' és csapata Cambridge-ben üzembe helyezte az ''EDSAC'' gépet, amely az első teljesen működő ''Neumann-elvek'' szerint tervezett számítógép lett. E fejlesztések lefektették a modern számítógépek architektúrájának alapjait. <span id="hardverrendszerek-és-processzorok"></span> === Hardverrendszerek és processzorok === A korai elektronikus számítógépek ''elektroncsövekre'' és ''relékre'' épültek. A Z3 és az ENIAC is több ezer elektroncső segítségével végezte a logikai műveleteket. Ezek a gépek hatalmas termeket töltöttek meg a hardver elemeivel és jelentős hőtermeléssel, energiafogyasztással jártak. A memória technológiája kezdetben mechanikus vagy elektronikus késleltető elem volt: például higany késleltetővonalak (higanycsövek) vagy kondenzátorok formájában tárolták a biteket, amelyeket folyamatosan frissíteni kellett (regeneratív memória az ABC-ben). '''John von Neumann''' 1945-ös híres jelentése, az ''First Draft of a Report on the EDVAC'', már leírta a ''tárolt program'' koncepcióját és a Neumann-architektúra elvét, amely szerint az utasítások és adatok ugyanabban a memóriában tárolhatók. Ez óriási előrelépést jelentett a hardver architektúrában: lehetővé tette a programok elektronikus tárolását és módosítását, megszüntetve a gép fizikai újrakábelezésének igényét az egyes feladatok között. 1947 decemberében a Bell Labs kutatói – '''William Shockley, John Bardeen és Walter Brattain''' – feltalálták a ''tranzisztort'', egy új szilárdtest-eszközt, amely az elektroncsöveknél jóval kisebb méretű és megbízhatóbb kapcsolóelemnek bizonyult. Bár ez a forradalmi találmány a ’40-es években még nem jelent meg a számítógépekben, megalapozta a későbbi generációs hardver fejlődését. Ugyanebben az évben, 1947-ben fejlesztette ki '''Kathleen Booth''' az első összeállító nyelvet (''assembly language'') a Birkbeck College-ban, Londonban – ezzel megjelent az igény, hogy a hardver szintű gépi kódnál emberközelibb formában is lehessen programozni. <span id="operációs-rendszerek"></span> === Operációs rendszerek === A 1940-es évek számítógépein még nem léteztek mai értelemben vett '''operációs rendszerek'''. A programokat gyakran közvetlenül gépi kódban vitték be (kapcsolótáblák, lyukkártyák vagy papírszalagok segítségével), és a gépek egyszerre jellemzően csak egy feladatot futtattak. A '''programozók''' maguk állították össze a végrehajtandó utasítássorozatot és indították el a számítógépet. A futás során minden erőforrás (processzoridő, memória) egy programé volt, így nem merült fel a többfeladatos üzem vagy erőforrás-kezelés igénye. A korabeli gépeken a programbetöltést és -vezérlést egyszerű kézi vagy vezérlőáramkörök (monitor programok) látták el, de ezek még nem alkottak külön szoftveres rendszert. Például az EDSAC számítógéphez '''Wilkes''' kidolgozta az ún. ''initial orders''-t (kezdő utasításokat) – ez egy kis program volt a gép memóriájában, amely megkönnyítette a lyukszalagról való betöltést és ezzel primitív vezérlő szoftverként működött. Összességében azonban az 1940-es években az operációs rendszer fogalma még nem létezett: a számítógépek közvetlen vezérlése és a futtatás menedzsmentje minden esetben a felhasználók és mérnökök feladata volt. <span id="programozási-nyelvek-és-fejlesztői-eszközök"></span> === Programozási nyelvek és fejlesztői eszközök === A számítástechnika hajnalán a programozás alapvetően ''gépi kódban'', azaz bináris vagy decimális műveleti kódok és memóriarekesz-címek sorozataként történt. A programozók – többnyire matematikusok és mérnökök – kézzel állították össze a gép utasításait. Az első áttörés ebben a '''assembly''', azaz assembly nyelv megjelenése volt: 1947-ben '''Kathleen Booth''' megalkotta az első assembly nyelvet, amely mnemonikus kódokkal (ember számára értelmezhető rövidítésekkel) helyettesítette a gépi kód bináris utasításait. Ez hatalmas segítséget jelentett, mert a programkód olvashatóbbá és könnyebben karbantarthatóvá vált. Emellett az assembly programokat egy ''assembler'' nevű szoftver fordította át gépi kóddá – ez tekinthető az első fejlesztői eszközök egyikének. Fontos megemlíteni '''Grace Murray Hopper''' nevét is, aki a ’40-es években a Harvard Mark I electromechanikus számítógépen dolgozott. 1947-ben Hopper dokumentálta az első ismert ''számítógépes “bugot”'': a Mark II egyik reléjébe szorult molylepkét, amely hibát okozott. Az eseményt tréfásan bejegyezték a naplóba mint „az első igazi ''bug''” – innen eredeztetik a ''debugging'' (hibakeresés) kifejezés használatát a szoftverfejlesztésben. Bár a “bug” szó technikai hibára már Thomas Edison idejében is használatos volt, a hopperi anekdota segített népszerűsíteni a kifejezést a számítástechnika területén. <span id="alkalmazási-területek"></span> === Alkalmazási területek === Az 1940-es években az akkor még szűk körben elérhető számítógépek főként '''tudományos és katonai célokra''' szolgáltak. A Colossus gépek a német hadsereg rejtjelfejtésében játszottak kulcsszerepet, lerövidítve a titkosított üzenetek megfejtésének idejét és ezzel hozzájárulva a szövetségesek hírszerzési sikereihez. Az ENIAC-ot eredetileg az amerikai hadsereg ballisztikus lövedék-pályatáblázatainak kiszámítására tervezték: a háború alatt ezeket a számításokat emberi számítók végezték, de a számítógép jelentősen felgyorsította a folyamatot. A háború után az ENIAC-ot tudományos kutatásokra használták, például a hidrogénbomba fejlesztéséhez szükséges szimulációk futtatására. 1949-ben az Egyesült Királyságban a '''Lyons cég LEO I''' számítógépe futtatta az első üzleti alkalmazást (bérszámfejtés) – ezzel kezdetét vette a számítógépek üzleti (kereskedelmi) alkalmazása. <span id="fontos-idézetek-és-koncepciók"></span> === Fontos idézetek és koncepciók === A korszakban formálódtak meg a számítástechnika alapvető elméleti koncepciói. '''Alan Turing''' brit matematikus már 1936-ban leírta az ''univerzális Turing-gép'' elvét, ami elméleti modellként megalapozta a számítógép fogalmát. 1950-ben Turing publikálta gondolatait a ''gépi értelem'' lehetőségéről, és felvetette a híres kérdést: „''Gondolkodhatnak-e a gépek?''”. Ebben a cikkben fogalmazta meg azt a kísérletet is, amelyet később ''Turing-tesztként'' ismerünk – bár ez már 1950-es esemény, a gondolat a ’40-es évek végének intellektuális légkörében gyökerezett. A Neumann-elvek (köztük a tárolt program koncepciója) a korszak végére széles körben elfogadottá váltak a szakemberek körében. Egy sokat idézett (bár vitatott hitelességű) jóslat 1943-ból szintén jól szemlélteti a kort: '''Thomas Watson''', az IBM akkori elnöke állítólag azt mondta, ''„talán öt darab számítógépre lehet igény világszerte”''. Függetlenül attól, valóban hangzott-e ez el, az idézet gyakran szerepel a korai számítógépek korlátozott felhasználhatóságával kapcsolatos vélekedések példájaként. Ugyancsak beszédes '''Howard H. Aiken''' 1950-ben megjelent nyilatkozata: „''Nagyobb problémákat kell kitalálnunk, ha azt akarjuk, hogy ezeknek a gépeknek legyen mit csinálni''” – utalva arra, hogy a korabeli számítógépek már a meglévő számítási feladatokat túl gyorsan megoldják. <span id="nyílt-problémák-és-versenyek"></span> === Nyílt problémák és versenyek === Az 1940-es években a számítástechnika legnagyobb nyílt problémája maga a '''megbízható és univerzális számítógép megalkotása''' volt. A korai gépek gyakran meghibásodtak (főként az elektroncsövek gyakori kiégése miatt) és programozásuk rendkívül időigényes volt. Az is nyitott kérdés volt, hogy lehet-e a számítógépeket a puszta számításnál összetettebb feladatokra használni, például utasításokkal ''önműködően'' irányítani egy folyamatot. Ez a probléma vezetett a tárolt programú vezérlés koncepciójához, amelyet Neumann János megoldott elméletben, és a késő ’40-es évekre megvalósult gyakorlatban is. A mesterséges intelligencia terén is fogalmazódtak meg kihívások: Turing említett gondolatkísérlete, a Turing-teszt felvetette egy olyan jövő versenyének lehetőségét, ahol egy gép és egy ember intelligens viselkedését kell megkülönböztetni. Bár ilyen verseny a ’40-es években még nem létezett, ez a felvetés évekkel később (1991-től a Loebner-díj keretében) valódi verseny formájában is megjelent. Összességében a 40-es évek végére a számítógépek terén a legfontosabb nyílt kérdés az volt, milyen mértékben lehet ezeket a gépeket általános célúvá tenni, és hol vannak a határai annak, amit géppel el lehet végezni – a következő évtizedek ezeket a kérdéseket kezdték el megválaszolni. <span id="es-évek-az-első-generációs-számítógépektől-a-tranzisztorokig"></span> == 1950-es évek – Az első generációs számítógépektől a tranzisztorokig == <span id="találmányok-és-első-használatok-1"></span> === Találmányok és első használatok === Az 1950-es évek elején a számítógépek kiléptek a laboratóriumokból és megkezdődött az '''első kereskedelmi gépek''' kora. 1951 márciusában üzembe helyezték az első kereskedelmileg sikeres számítógépet, az ''UNIVAC I''-et, amelyet '''J. Presper Eckert''' és '''John Mauchly''' tervezett. Az UNIVAC volt az első általános célú elektronikus számítógép, amelyet üzleti és adminisztratív adatok (szövegek, számok) feldolgozására is szántak, nem csak tudományos számításokra. Ugyanebben az évben, 1951-ben a brit '''Lyons''' cég ''LEO I'' számítógépe futtatta az első üzleti szoftvert (egy fizetési jegyzék feldolgozását), bizonyítva, hogy a számítógépek a kereskedelmi szektorban is hasznosíthatók. A kormányzati és katonai szférában is egyre több alkalmazás jelent meg: 1951-ben '''Jay Forrester''' és csapata a MIT-en befejezte a ''Whirlwind'' számítógépet, amely az első '''valós idejű számítógép''' volt és interaktív módon, katódsugaras kijelzőn keresztül lehetett vezérelni. A Whirlwind tapasztalataira építve az amerikai légierő megalkotta a ''SAGE'' (Semi-Automatic Ground Environment) légvédelmi rendszert, amely a ’50-es évek végére a számítógépes hálózatba kötött radarfigyelés és -irányítás úttörőjévé vált. 1950-ben '''Alan Turing''' publikációja (amely később a ''Turing-teszt'' nevet kapta) felvetette a gépi intelligencia lehetőségét és megalapozta a mesterségesintelligencia-kutatás elméleti kereteit. 1956 nyarán Dartmouth College-ban egy konferencián neves kutatók (köztük '''John McCarthy, Marvin Minsky''' és mások) találkoztak, ahol megszületett a ''„mesterséges intelligencia”'' kifejezés, és ezzel elindult az AI, mint kutatási terület – ennek eredményeképp a ’50-es évek végén például '''Newell, Simon és Shaw''' kifejlesztették a ''Logic Theorist'' és a ''General Problem Solver'' programokat, melyek az emberi gondolkodás szimulálására tettek kísérletet. Az évtized során a számítógépek egyre nagyobb teljesítményűek lettek, ám ekkor még mindig ''elektroncsöveket'' használtak (ezért hívjuk ezeket ''első generációs'' számítógépeknek). 1959-re a világ számos pontján működtek elektroncsöves számítógépek; ebben az évben jelent meg például az első japán elektronikus számítógép, a ''FUJIC'', illetve a Szovjetunióban is fejlesztettek saját gépeket (MESM, BESZM stb.). 1959 és 1964 között gyártott gépeket szokás az első generációba sorolni, ekkorra kb. 2000 számítógép működött világszerte. <span id="hardverrendszerek-és-processzorok-1"></span> === Hardverrendszerek és processzorok === A ’50-es évek közepéig a számítógépek elektroncsöves technológián alapultak. Ezek a gépek hatalmasak voltak és rendkívül sok hőt termeltek, ami gyakori meghibásodásokhoz vezetett. 1954-ben azonban egy forradalmi változás kezdődött: az elektroncsöveket fokozatosan felváltották a ''tranzisztorok''. Az első tranzisztoralapú számítógépek közé tartozott például a '''TX-0''' (1956, MIT), amely kísérleti gépként demonstrálta, hogy egy számítógép felépíthető teljes egészében tranzisztorokkal. 1959-re a számítógépek második generációja, a '''tranzisztoros gépek''' megjelentek: kisebbek, gyorsabbak és megbízhatóbbak lettek. Az IBM 1959-ben jelentette be az ''IBM 7090'' gépet, ami tranzisztoros változata volt a korábbi 709-es csöves számítógépnek, és sokkal nagyobb teljesítményt nyújtott. Egy másik fontos hardver-innováció a memória terén történt: az elektroncsöves és késleltetővonalas memóriákat felváltották a '''mágneses magtárak'''. 1953-ra a mágneses ferritgyűrűkből álló ''magtár'' memória standarddá vált a számítógépekben (például a Whirlwind-ben is ezt alkalmazták). A magtárak megbízható, véletlen elérésű memóriát biztosítottak, amely megőrizte tartalmát áramkimaradás esetén is. Ez jelentősen megnövelte a gépek teljesítményét és használhatóságát. 1958-ban új fejezet nyílt a hardver történetében: '''Jack Kilby (Texas Instruments)''' és '''Robert Noyce (Fairchild Semiconductor)''' egymástól függetlenül feltalálták az ''integrált áramkört (IC)'', amely több tranzisztort és áramköri elemet egyetlen félvezető lapkára integrált. Bár az integrált áramkörök a ’50-es évek végén még kezdetlegesek voltak és a számítógépekben csak a ’60-as években terjedtek el, ez a találmány megalapozta a későbbi mikroprocesszorok és modern számítógépek lehetőségét. Az integrált áramkörök megjelenésével beszélhetünk a ''harmadik generációs'' számítógépek kezdetéről, bár ennek kibontakozása inkább a következő évtizedre esik. <span id="operációs-rendszerek-1"></span> === Operációs rendszerek === Az 1950-es évek elején a számítógépek még mindig egy felhasználós, egyprogramos üzemmódban működtek. A programokat lyukkártyákon vagy szalagon adták be, és a gépek addig futtatták őket, amíg véget nem értek. Az évtized közepén azonban megjelent az igény a hatékonyság növelésére: a számítógépidő drága volt, ezért kifejlesztették az első ''soros feldolgozó (batch processing)'' rendszereket. 1956-ban az '''IBM''' egyik gépén futott az első egyszerű ''batch monitor'' program: ez volt a '''GM-NAA I/O''', amelyet az General Motors megbízásából írtak az IBM 701 számítógépre. A GM-NAA I/O alapvetően egy kezdetleges operációs rendszer volt, amely sorban egymás után betöltötte és lefuttatta a lyukszalagon sorakozó feladatokat, emberi beavatkozás nélkül. A ’50-es évek végére az operációs rendszerek előfutáraiként olyan szoftverek jelentek meg, amelyek automatizálták a feladatok ütemezését és az eszközkezelést. 1959-ben az '''MIT''' kifejlesztette a ''Compatible Time-Sharing System'' (CTSS) elődjét megalapozó koncepciókat, bár maga a CTSS csak 1961-ben indult el. Összességében a ’50-es évek végén az operációs rendszerek még gyerekcipőben jártak: a legtöbb gép csak feladatkezelő monitorprogramokkal rendelkezett, de a következő évtizedben ugrásszerű fejlődés indult, ahogy a gépek teljesítménye és felhasználói száma nőtt. <span id="programozási-nyelvek-és-fejlesztői-eszközök-1"></span> === Programozási nyelvek és fejlesztői eszközök === A programozás forradalmi változásokon ment keresztül az 1950-es években. Míg a korai években az assembly nyelv jelentett előrelépést, hamar felismerték, hogy magasabb szintű, az emberi gondolkodáshoz közelebb álló '''programozási nyelvekre''' van szükség. 1957-ben az '''IBM''' mérnöke, '''John Backus''' kifejlesztette a ''FORTRAN'' nyelvet (Formula Translator), amely kifejezetten tudományos és mérnöki számításokhoz készült. A FORTRAN volt az első széles körben használt '''magasszintű programozási nyelv''', és fordítóprogramja hatékony kódot állított elő, így a tudósok és mérnökök körében gyorsan népszerű lett. Ezt követte 1958-ban a '''LISP''' nyelv ('''John McCarthy''' és társai) – a mesterséges intelligencia kutatás igényeire szabva, a listák és rekurzív adattípusok kezelésével. 1959-ben pedig '''Grace Hopper''' közreműködésével létrejött a ''COBOL'' (Common Business-Oriented Language), amelyet üzleti adatok feldolgozására optimalizáltak. A COBOL nagy előnye az volt, hogy hasonlított az angol nyelvhez, így a kormányzati és üzleti alkalmazások programozását szélesebb kör számára tette hozzáférhetővé. A fejlesztői eszközök is fejlődtek: megjelentek az első '''fordítóprogramok''' (compiler-ek), melyek automatikusan lefordították a magasszintű nyelveken írt programokat gépi kódra. A FORTRAN fordítója (1957) mérföldkő volt, bizonyítva, hogy a gépi kódú programok hatékonysága elérhető automatikus fordítással is. 1952-ben Grace Hopper már elkészítette az A-0 nevű fordítóprogramot, amely a gépi kódú szubrutinokat linkelte össze magasabb szintű utasítások alapján – egyesek ezt tekintik az első igazi compilernek. A ’50-es évek végére a programozók rendelkezésére álltak assembler-ek, compiler-ek, és kezdetleges ''debuggerek'', így a szoftverfejlesztés egyre inkább különvált a hardver építésétől. <span id="alkalmazási-területek-1"></span> === Alkalmazási területek === Ebben az évtizedben a számítógépek alkalmazása rohamosan bővült. Továbbra is fontosak maradtak a '''tudományos számítások''': a FORTRAN megjelenése például forradalmasította a numerikus szimulációkat a mérnöki és fizikai kutatásokban. Szuperszonikus repülőgépek tervezésénél, atomfizikai számításoknál már számítógépet használtak a bonyolult differenciálegyenletek megoldására. Az '''üzleti életben''' a számítógépek lassan kezdtek meghonosodni. A COBOL nyelv és az olyan számítógépek, mint az UNIVAC, megmutatták, hogy a könyvelés, raktárkezelés, banki nyilvántartások automatizálhatók. 1954-ben egy GE 225 számítógépen futott az első '''banki információs rendszer''' (a Bank of America számára készült ERMA rendszer, bár teljes üzembe csak 1961-ben állt), ami feldolgozta a csekkeket és frissítette a számlaegyenlegeket. A '''kormányzati szektorban''' és a nagyvállalatoknál a számítógépek elsősorban adatfeldolgozásra és nyilvántartásra találtak alkalmazást. Például az USA Népszámlálási Hivatala is UNIVAC gépeket használt az 1950-es népszámlálási adatok feldolgozására. A katonai alkalmazások között a SAGE légvédelmi rendszer mellett megjelent a ballisztikus rakéták navigációját segítő számítógépes rendszer is (a ''NAVSAT'' elődje), valamint a hadseregen belül logisztikai és kommunikációs feladatokra is kezdték bevetni az elektronikus számítógépeket. Az 1950-es évek végén egy különleges alkalmazási terület is felbukkant: a '''számítógépes zene'''. 1957-ben '''Max Mathews''' a Bell Labs-nál kifejlesztette a Music I szoftvert, mely lyukszalagról olvasott kottát és hangot generált – ez volt a számítógéppel komponált zene kezdete. 1951-ben Manchesterben a Ferranti Mark 1 gép pedig egyszerű dallamokat játszott le – ezek a legrégebbi ismert számítógép által generált zenei felvételek. <span id="fontos-idézetek-és-koncepciók-1"></span> === Fontos idézetek és koncepciók === A ’50-es években vált világossá, hogy a számítógépek rendkívül gyors fejlődése új kihívásokat és koncepciókat szül. 1952-ben '''John von Neumann''' azt nyilatkozta, hogy ''„számunkra, akik láttuk a számítógépek születését, nehéz elképzelni, hova vezet mindez”''. Ez a bizonytalanság a szakemberek között is jelen volt: sokan vitatták, hogy a számítógépek alkalmasak lehetnek-e műfordításra, játékokban való gondolkodásra vagy akár gépi tanulásra. 1956-ban a Dartmouth konferencián '''Marvin Minsky''' optimistán kijelentette: ''„a mesterséges intelligencia problémáinak lényegét egy nyár alatt meg lehet oldani”''. Ez a túlzott optimizmus később, a ’60-as évek végére ''„AI-tél”'' néven emlegetett kiábránduláshoz vezetett, de a ’50-es évek közepén még nagy lendület és hit övezte az AI kutatást. A programozás terén '''Edsger Dijkstra''' 1957-ben (még Hollandiában) megalkotta az első fordítási algoritmust az ALGOL nyelvhez, és ezzel megalapozta a ''struktúrált programozás'' későbbi mozgalmát. '''Grace Hopper''' egyik híres idézete ebből az időből: ''„Nehéz meggyőzni az embereket, hogy a számítógép nem az ördög műve, csak azért, mert számolni tud”'' – utalva arra az attitűdre, amivel sok laikus vagy akár üzletember tekintett a számítógépekre: misztikus, bonyolult eszközként. <span id="nyílt-problémák-és-versenyek-1"></span> === Nyílt problémák és versenyek === Az 1950-es években a számítógépes világ számos nyílt problémával nézett szembe. Az egyik fő kihívás a '''megbízhatóság és skálázhatóság''' volt: hogyan lehet a gépeket kevésbé hibafogékonnyá tenni és egyszerre több feladatot futtatni. Ez a probléma ösztönözte az operációs rendszerek és a tranzisztoros hardver fejlesztését. A '''szoftverfejlesztés''' is problémákkal küzdött. Ahogy a programok bonyolódtak, egyre világosabbá vált, hogy a programozás módszertanát fejleszteni kell. A későbbi ''„szoftverválság”'' első jelei már mutatkoztak: nagy projekteknél csúszások és költségtúllépések voltak. Ennek előszelét a NATO 1968-as konferenciáján nevezték el szoftverválságnak, de az alapjai a ’50-es évek végén gyökereztek, amikor a COBOL és FORTRAN projektek kapcsán felmerült a dokumentáció és karbantarthatóság fontossága. A mesterséges intelligenciában nyílt kérdés volt, hogy vajon egy gép képes lehet-e például sakkozni emberi szinten. 1950-ben '''Claude Shannon''' írt egy tanulmányt a számítógépes sakkról, ami aztán versenyhelyzeteket inspirált: 1956-ban már rendeztek primitív számítógépes sakkversenyt (IBM vs. NSS programok között). Az igazi nagy '''verseny''' azonban ebben a korban még inkább elvi jellegű volt: ember vs. gép. 1956-ban az NSSCs (Nemzetközi Sakk Számítógép Konferencián) bemutatták az első sakkprogramokat, de gép még nem győzött le mesterszintű sakkozót. Ez a kihívás csak évtizedekkel később, 1997-ben oldódott meg, amikor az IBM Deep Blue legyőzte Garri Kaszparovot. Ugyancsak nyitott probléma volt a '''gépi fordítás''': 1954-ben egy orosz–angol gépi fordítási kísérlet (Georgetown-IBM kísérlet) biztató eredményt hozott, de hamar világossá vált, hogy a nyelv feldolgozása sokkal nehezebb feladat, semmint pár év alatt megoldható legyen – ez a probléma is velünk maradt még évtizedekig. Összességében a ’50-es évek végére a számítástechnika közössége számos ígéretet és ugyanakkor problémát látott maga előtt: a számítógépek egyre gyorsabbak és hasznosabbak lettek, de kérdés volt, hogyan lehet őket hatékonyan programozni, több feladatot párhuzamosan kezelni, és vajon meddig fokozható a teljesítményük – ezek a kérdések a következő évtizedek kutatásait meghatározták. <span id="as-évek-integrált-áramkörök-és-a-szoftverek-születése"></span> == 1960-as évek – Integrált áramkörök és a szoftverek születése == <span id="találmányok-és-első-használatok-2"></span> === Találmányok és első használatok === A 1960-as évekre a számítógépek második generációja – a tranzisztoros gépek – már kiforrott, és az évtized során átlépünk a '''harmadik generációba''', amit az ''integrált áramkörök (IC)'' alkalmazása jellemez. 1960-ban a Bell Labs kutatói megépítették az első működő '''MOSFET tranzisztort''' (fém-oxid-félvezető tranzisztort), ami később a modern mikroprocesszorok alapja lett. 1961-ben a '''Texas Instruments''' bemutatta az első integrált áramkörökre épülő kísérleti számítógépet, a ''Molecular Electronic Computer''-t, bizonyítva hogy az IC-technológia alkalmas számítógép építésére. Az évtized elején – 1964-ben – az '''IBM bemutatta a System/360 családot''', az első olyan számítógéprendszert, amely különböző méretű és teljesítményű modelleket kínált, de közös utasításkészlettel. Ez forradalmi volt, mert a korábbi években minden új számítógépmodellhez a szoftvereket újra kellett írni. A System/360 egységes platformot teremtett a kis és nagy gépek között, és ezzel az IBM dominánssá vált a mainframe piacon. A System/360 emellett 8 bites ''bájt'' egységet használt (ez a bájt definíciója itt rögzült ipari szabványként), és egy sor új technológiát vezetett be (például mikroprogramozást, tranzisztoros áramköröket, stb.). A ’60-as években a számítógépek megjelentek a '''kutatás''' számos területén és új alkalmazások születtek. 1965-ben üzembe állt a '''CDC 6600''', a világ első szuperszámítógépe, amelyet '''Seymour Cray''' tervezett a Control Data Corporationnél. A CDC 6600 1964-ben debütált és ~3 millió műveletet végzett másodpercenként, megelőzve minden korábbi gépet. Ez a gép vezette be a ''párhuzamos feldolgozás'' bizonyos elemeit (több funkcionális egységen keresztüli utasításkivitelezés), és évekig a leggyorsabb számítógép volt. Az évtized második felében, 1969-ben egy kis lépés az emberiségnek, nagy ugrás a számítástechnikának: az '''ARPANET''' projekt keretében létrejött az első számítógép-hálózat csírája. 1969. november 21-én sikerült összekapcsolni két távoli gépet (UCLA és Stanford), létrehozva az első két csomópontos hálózatot – ez lett az ARPANET magja. Bár ekkor még csak négy csomópontból állt a hálózat (1969 végére), az ARPANET a későbbi internet előfutára volt, és a ’60-as évek végén megszülettek a hálózati kommunikáció alapvető protokolljai és eszközei (pl. '''RFC 1''' – az első Request for Comments dokumentum 1969 áprilisában jelent meg, formalizálva a hálózati protokollok fejlesztését). <span id="hardverrendszerek-és-processzorok-2"></span> === Hardverrendszerek és processzorok === A hardver terén a ’60-as évek forradalmi újdonsága az '''integrált áramkörök''' egyre szélesebb körű alkalmazása volt. 1962-re a Manchesteri Egyetemen elkészült az ''Atlas'' számítógép, mely ugyan még tranzisztoros volt, de számos újításával – mint a párhuzamos feldolgozás, szimultán I/O műveletek és a ''virtuális memória'' – megelőlegezte a következő generáció képességeit. Az Atlas a világ egyik legerősebb gépe volt megjelenésekor, és bevezette a ''lapozást'' (paging) a memóriakezelésben, lehetővé téve a programok számára, hogy a fizikai memóriánál nagyobb memóriateret használjanak. 1965-re a tranzisztoros technológia csúcsra ért a ''miniszámítógépek'' megjelenésével: a '''Digital Equipment Corporation (DEC)''' kiadta a ''PDP-8'' gépet, ami az első kereskedelmileg sikeres miniszámítógépnek tekinthető. A PDP-8 relatíve olcsó ($18 000 körüli ár), kis helyigényű gép volt, melyet laborokban, egyetemeken és kisebb cégeknél is alkalmazni tudtak – ezzel elkezdődött a számítástechnika decentralizációja, nem csak óriási vállalatok engedhették meg maguknak a gépeket. 1969-ben a '''Honeywell''' bemutatta a ''Honeywell 316'' miniszámítógépet, amely integrált áramköröket használt, és a Bell Labs ezt a gépet alkalmazta az első '''programozható logikai vezérlő (PLC)''' létrehozására ipari folyamatok vezérléséhez (ez a ''Project MAC'' része volt). Eközben 1969-ben az '''Intel''' megkezdte első mikroprocesszorának fejlesztését, a 4-bites ''4004'' chip tervezését – bár maga a 4004 csak 1971-ben készült el, a ’60-as évek végén indult projekt volt a mikroprocesszor születésének előjátéka. A ’60-as évek közepétől a ''második generációs'' gépeket (tranzisztoros) fokozatosan felváltották a ''harmadik generációs'' gépek. Ez utóbbiakban már '''IC-ket''' alkalmaztak, ami nagyságrendi növekedést hozott az integráltságban és megbízhatóságban. Az IBM System/360 család, valamint a DEC újabb gépei (PDP-11, 1970 körül) mind integrált áramkörös logikával készültek. Az integrált áramkörök kezdetben ''kis integráltságú'' (SSI) és ''közepes integráltságú'' (MSI) chipeket jelentettek, melyeken néhány tíz vagy száz tranzisztor volt. A ’60-as évek végére megjelent a ''nagymértékben integrált áramkör'' (LSI), több ezer tranzisztorral – ennek köszönhetően a komplett processzorok a következő évtizedben már egy lapkára kerülhettek. <span id="operációs-rendszerek-2"></span> === Operációs rendszerek === A 1960-as években az operációs rendszerek terén hatalmas fejlődés zajlott: kialakultak a mai OS-ek alapvető funkciói – mint a többfeladatos működés, párhuzamos felhasználói elérés és a különböző hardver-erőforrások dinamikus kezelése. 1961-ben a '''MIT''' kifejlesztette a ''CTSS'' (Compatible Time-Sharing System) rendszert kísérleti jelleggel, amely 1961-ben demonstrálta, hogy egy számítógépet (IBM 7090) több felhasználó terminálokon keresztül egyszerre, időosztásos módon használhat. A ''time-sharing'', azaz időosztásos üzemmód forradalmasította az interaktív számítógép-használatot, hiszen már nem kellett órákat vagy napokat várni egy batch feladat eredményére – a felhasználók közvetlenül kommunikálhattak a géppel. 1964-ben a '''Dartmouth College'''-ban kifejlesztették a Dartmouth Time-Sharing System-et, és ennek részeként a BASIC programozási nyelvet, amely egyszerű szintaxisával a diákok interaktív tanítására szolgált. A BASIC interpreter futtatása egy időosztásos rendszeren lehetővé tette, hogy sok diák egyszerre programozzon egy központi gépen, ami a számítógépek oktatási alkalmazását erősen fellendítette. Az IBM System/360 bevezetésével párhuzamosan az IBM megalkotta az OS/360 operációs rendszert (1966-ra vált stabillá), ami már rendkívül összetett, többfeladatos OS volt: batch munkákat, spoolingot (perifériák közötti pufferelést) és különböző nyelvekhez fordítókat tartalmazott. Az OS/360 a megbízhatóság és az akkori hardver maximális kihasználása érdekében jött létre, és hozzájárult az ''„operációs rendszerek”'' fogalmának elterjedéséhez. A korszak talán legfejlettebb kísérleti OS-e a '''Multics''' (Multiplexed Information and Computing Service) volt, amelyet 1964-től kezdődően fejlesztett a MIT, a Bell Labs és a GE közösen. A Multics számos újdonságot vezetett be: dinamikus újrafordítás, fájlrendszer hierarchia, biztonsági védelem és egy akkor forradalmi koncepció: ''újrabelépő kernel'' moduláris felépítéssel. Bár a Multics végül csak korlátozott körben terjedt el, közvetlen hatása óriási volt – például inspirálta az 1969-ben megszületett '''UNIX''' operációs rendszert. 1969-ben a Bell Labs fiatal programozói, '''Ken Thompson és Dennis Ritchie''' létrehozták a UNIX első verzióját, kezdetben egy DEC PDP-7 gépen. A UNIX egyszerűbb volt a Multicsnál, de átvette annak sok jó ötletét, és a ’70-es évekre a UNIX vált a többfelhasználós operációs rendszerek etalonjává. Megjelent a rendszerhívások koncepciója, a fájlkezelés egységes elve (mindent fájlként kezelünk), és a csővezetékek (pipeline) ötlete is. A ’60-as évek végére tehát az operációs rendszerek már elérték azt a komplexitást, hogy a ''szoftver'' külön iparággá válhatott. <span id="programozási-nyelvek-és-fejlesztői-eszközök-2"></span> === Programozási nyelvek és fejlesztői eszközök === A 60-as évek hihetetlen pezsgést hoztak a programozási nyelvek terén. 1960-ban megjelent az '''ALGOL 60''', amely a struktúrált, blokkos programozás első valóban nemzetközi nyelve lett, és bevezette a máig használt szintaktikus elemek egy részét (begin-end blokkok, rekurzió stb.). Bár az ALGOL-t főleg az akadémiai és matematikai körök használták, hatása óriási volt a későbbi nyelvekre (Pascal, C, stb.). 1964-ben '''John Kemeny és Thomas Kurtz''' elkészítette a '''BASIC''' nyelvet (Beginner’s All-purpose Symbolic Instruction Code), kifejezetten az egyszerűség kedvéért, hogy diákok könnyen megtanulhassák. A BASIC gyorsan elterjedt az egyetemeken a time-sharing rendszereken, mivel interaktív tolmácsként működött, azonnali visszajelzést adva a tanulóknak. 1967-ben Norvégiában '''Ole-Johan Dahl és Kristen Nygaard''' kifejlesztették a '''Simula 67''' nyelvet, amit sokan az első ''objektumorientált programozási nyelvnek'' tekintenek. A Simula-ban jelentek meg először az „objektum” és „osztály” fogalmak (igaz, ők még inkább szimulációs kontextusban használták, pl. folyamatok modellezésére), de ez a koncepció később alapja lett számos nyelvnek (Smalltalk, C++ stb.) és a szoftverfejlesztés új paradigmájának. A ''hálózati protokollok'' fejlődésével új szkriptnyelvek is születtek: például 1969-ben a ''BCPL'' nyelvből (egy egyszerű rendszerszintű nyelvből) '''Ken Thompson''' megírta a ''B nyelvet'' a UNIX fejlesztéséhez, majd 1970-ben '''Dennis Ritchie''' továbbfejlesztette ezt ''C nyelvvé'' a Bell Labs-nál. A C nyelv azonban hivatalosan 1972-ben jelent meg, így a ’60-as évek végén még csak formálódott – de meg kell említeni, mert a tervezési folyamat már a UNIX alkotása közben elindult. A fordítóprogramok és egyéb fejlesztői eszközök terén is előrelépés történt. 1962-ben megjelent az első '''fordítófordító''' (compiler-compiler), az IBM ''FLOW-MATIC'' és hasonló eszközök utódaként az ''YACC'' (Yet Another Compiler-Compiler) 1970-ben – ezek célja az volt, hogy megkönnyítsék új nyelvek fordítóinak létrehozását. A ''szimbólikus debug'' eszközök is megjelentek: pl. a '''IBM''' fejlesztette ki az első hibakereső programokat nagygépein, és a felhasználók elkezdték használni a ''„print debugging”'' helyett a memóriatartalom vizsgálatára szolgáló szoftvereket. 1968 egy fontos év volt a szoftverfejlesztés történetében: a NATO konferencián elhangzott '''Edsger Dijkstra''' híres cikke: ''„Go To Statement Considered Harmful”'', amely a goto utasítás túlzott használata ellen érvelt és a struktúrált programozás mellett tette le a voksát. Ugyanebben az évben beszéltek először nyíltan a ''„szoftverválságról”'': arról, hogy a szoftverek komplexitása meghaladja a fejlesztési módszerek képességeit, és új szemléletre van szükség – így született meg a ''szoftverfejlesztés mint mérnöki diszciplína'' (software engineering) gondolata. <span id="alkalmazási-területek-2"></span> === Alkalmazási területek === A ’60-as években a számítógépek behatoltak az élet szinte minden területére, legalábbis a fejlett országokban. A '''tudományos kutatás''' terén a számítógépek nélkülözhetetlenné váltak: a NASA az 1960-as években számítógépeket alkalmazott az ''űrkutatásban'', például a Mercury és Gemini programokban a röppályák számítására, majd az Apollo program során a fedélzeti számítógép (AGC – Apollo Guidance Computer) irányította a holdkompot. Ez utóbbi egy 2 MHz alatti, 2kB RAM-mal rendelkező integrált áramkörös minigép volt, amely kihívások közt is bizonyított, például az Apollo–11 holdraszállásakor, amikor a program újraindult túlterhelés miatt, de a szoftver ''hibatűrő'' kialakítása lehetővé tette a küldetés folytatását. A '''katonai alkalmazások''' közül a stratégiai fegyverrendszerek és korai figyelmeztető rendszerek emelhetők ki: a SAGE rendszer a ’60-as években vált teljesen működőképessé, egy észak-amerikai radarrendszer-hálózatot kötve össze hatalmas ''AN/FSQ-7'' számítógépekkel. Ezek a gépek valós idejű adatokat dolgoztak fel és vadászrepülőket irányítottak – lényegében az első ''online'' hálózati rendszernek tekinthetők. A rakétavédelemben és az űrversenyben a számítógépek szintén kulcsszerepet játszottak. Az '''üzleti életben és kormányzatban''' a ’60-as évek hozta el az ''adatbázis-kezelés'' kezdetét. 1965-ben az IBM létrehozta az első nagyszabású adatbázis-rendszereket például a szociális biztonsági nyilvántartáshoz. 1964-ben indult útjára a '''SABRE''' nevű légifoglalási rendszer az American Airlines és az IBM közös projektjeként – ez a rendszer több várost összekapcsolva valós időben kezelte a repülőjegy-foglalásokat, és úttörő lett az online tranzakciófeldolgozásban. A '''telekommunikációban''' is megjelentek a számítógépek: az 1960-as években a telefonhálózatok kapcsolóközpontjait kezdték el digitalizálni. 1965-ben a Bell Labs kifejlesztette az első ''elektronikus telefonközpontot'' (ESS – Electronic Switching System), amelyben számítógép irányította a híváskapcsolást, javítva a hálózat megbízhatóságát és kapacitását. A '''hálózatok''' terén, ahogy említettük, 1969-ben az ARPANET létrejötte új alkalmazási lehetőségeket nyitott: eleinte a tudományos és katonai intézmények között osztottak meg erőforrásokat (pl. egy-egy különleges nyomtatót vagy számítógépet távolról használtak). 1965-ben '''Donald Davies''' és '''Paul Baran''' egymástól függetlenül leírták a ''csomagkapcsolt hálózatok'' elvét, ami az ARPANET és később az internet alapja lett. 1969-re nem csak az USA-ban, de az Egyesült Királyságban (NPL network) és máshol is kísérleteztek hálózatokkal – sőt, 1973-ban létrejött az első nemzetközi hálózati kapcsolat London és az ARPANET között. A '''szórakoztatóiparban''' is megjelentek az első fecskék: 1962-ben a MIT-n megírták a ''Spacewar!'' nevű számítógépes játékot egy DEC PDP-1 gépen, ami két játékosnak biztosított interaktív élményt – ez a játék a hacker-kultúra egyik legendája lett. Bár kereskedelmi forgalomba nem került, a Spacewar inspirálta később, 1971-ben az első coin-op videojátékot (Computer Space). A ’60-as évek tehát a számítógépes játékok és a digitális szórakoztatás csíráit is hordozta magában. <span id="fontos-idézetek-és-koncepciók-2"></span> === Fontos idézetek és koncepciók === A ’60-as évek elején '''Gordon Moore''', az Intel társalapítója, 1965-ben megfogalmazta a később ''Moore-törvényként'' ismert megfigyelését: miszerint az integrált áramkörökön a tranzisztorok száma (és ezzel a számítógépek teljesítménye) nagyjából kétévente megduplázódik. Ez a „törvény” döbbenetes pontossággal jellemezte a következő évtizedek fejlődését, és a félvezetőipar önbeteljesítő céljává vált. 1968-ban a már említett '''Dijkstra'''-cikk, a ''„Go To statement considered harmful”'', alapvető szemléletváltást indított a programozásban: a struktúrált programozás térnyerése kezdődött, ami a programozási nyelvek és módszerek letisztulásához vezetett. Dijkstra egy másik híres mondata 1968-ból: ''„A szoftverfejlesztés katasztrofális állapotban van”'' – ezzel a szoftverválságra utalt, ami akkor már érzékelhetően fenyegette a nagy projekteket. 1969-ben '''Ken Thompson''' és '''Dennis Ritchie''' a ''„Unix filozófia”'' szellemében alkották meg a UNIX rendszert, melynek része egy máig idézett elv: ''„Készíts egyszerű dolgokat, amelyek jól működnek együtt”''. A UNIX kis, jól körülhatárolt eszközökből állt, amelyeket csővezetékekkel lehetett összefűzni – ez a filozófia a szoftvertervezés tartós koncepciójává vált. A NASA holdraszállása kapcsán '''Gene Kranz''', az irányítóközpont vezetője kijelentette: ''„Failure is not an option”'' („a kudarc nem opció”), ami ugyan emberi vonatkozású mottó, de jól tükrözi azt a megbízhatósági szemléletet, amit a ’60-as években a számítógépektől is elvártak, különösen kritikus alkalmazásokban. Ugyanebben az időben hallhattuk '''John F. Kennedy''' 1961-es beszédét is: ''„Eldöntöttük, hogy még ebben az évtizedben embert juttatunk a Holdra és vissza is hozzuk biztonságban”'' – ez a kihívás a számítástechnika fejlődését is felgyorsította, hiszen az űrprogram rengeteg újítást igényelt a navigáció, vezérlés és számítógép-irányítás terén. <span id="nyílt-problémák-és-versenyek-2"></span> === Nyílt problémák és versenyek === A ’60-as években számos, ma ismerős probléma kezdett körvonalazódni. Az egyik ilyen a '''szoftver méretének és komplexitásának kezelése''' – az évtized végén megfogalmazott szoftverválság lényege, hogy a hagyományos eszközökkel nem lehet könnyen áttekinteni és karbantartani az egyre bonyolultabb programokat. Erre válaszul a struktúrált programozás és később az objektumorientált programozás kínált megoldást, de a kérdés nyitott maradt, hogyan lehet igazán nagy szoftvereket ''„mérnöki alapossággal”'' készíteni. A '''hardver terén''' is volt nyitott kérdés: a ''Miniaturizálás'' határai meddig tolhatók? Moore törvénye ugyan iránymutatást adott, de a mérnökök már a ’60-as években felismerték, hogy előbb-utóbb fizikai korlátokba ütközhetnek. Akkoriban a gond inkább az integrálás megbízhatóságával és a hőelvezetéssel volt, de a következő évtizedekre előre tekintve a kérdés mindig ott lebegett, meddig skálázható a technológia. Az '''ember-gép kapcsolat''' is nyitott kihívást jelentett. 1968. december 9-én '''Douglas Engelbart''' tartott egy híres bemutatót (a „Mother of All Demos”-t), ahol megmutatta az általa kitalált ''egér'' használatát, a grafikus felület csíráit (ablakok), hipertextet és videókonferenciát is. Bár a technológia készen állt, nyitott kérdés volt, hogyan lehetne ezt széles körben elterjeszteni és valóban felhasználóbaráttá tenni a számítógépeket. Az Engelbart által felvetett ötletek megvalósítása és tökéletesítése a ’70-es, ’80-as évek feladata lett (Xerox PARC, majd Apple és Microsoft munkái révén). A '''mesterséges intelligenciában''' is maradtak nyitott problémák: bár a kezdeti optimizmus nagy volt, a határok is megmutatkoztak. 1967-re megjelentek az első ''nyelvfordító'' programok (gépi fordítás), de messze elmaradtak a várt szinttől; a gépi látás és a hangfelismerés pedig még kezdetleges stádiumban volt. Az ''AI versenyek'' közül említést érdemel, hogy 1966-ban az ELIZA program (Joseph Weizenbaum) ugyan elkápráztatta a laikusokat pszichoterapeuta-szimulációjával, de a szakmabeliek látták, hogy a mesterséges intelligencia átment egy túlzott hype-on, amit a források ideiglenes apadása követett (AI-tél a ’70-es években). Verseny szempontjából a '''számítógépes sakk''' egy fontos terület volt: 1967-ben a MacHack VI program megnyerte az első sakkmérkőzést egy amatőr sakkjátékos ellen, és 1970-ben rendezték az első ''Nemzetközi Számítógépsakk-bajnokságot''. Tehát a ’60-as évek végére a számítógépek közötti versengés elkezdődött az AI területén, bár ezek inkább barátságos megmérettetések voltak. A ''programozói versenyek'' is megjelentek egyetemi berkekben: a diákok összevetették BASIC vagy FORTRAN tudásukat, de a formális nemzetközi programozói versenyek (mint az '''ACM ICPC''') csak 1977-ben indultak. Összességében a ’60-as évek végén a számítástechnika hihetetlen távlatokat nyitott, de egyúttal rávilágított a még megoldásra váró nehézségekre – a következő évtizedek ezen problémák közül sokat meg is oldottak. <span id="es-évek-a-mikroprocesszor-és-a-személyi-számítógép-születése"></span> == 1970-es évek – A mikroprocesszor és a személyi számítógép születése == [[File:Intel_C4004.jpg|thumb|Az Intel 4004 mikroprocesszor (1971) – az első kereskedelmi forgalomban kapható egylapkás központi feldolgozóegység, amely 4 biten működött és ~2300 tranzisztort tartalmazott.]] <span id="találmányok-és-első-használatok-3"></span> === Találmányok és első használatok === A 1970-es évek elején a számítástechnika új korszakba lépett a '''mikroprocesszorok''' megjelenésével. 1971. november 15-én az '''Intel''' piacra dobta a ''4004'' jelű mikroprocesszort, a világ első egyetlen chipre integrált CPU-ját. A 4004 csupán 4 bites adatszélességű volt és nagyjából 2300 tranzisztort tartalmazott, de képes volt másodpercenként ~60 000 művelet végrehajtására. Hamarosan követték erősebb testvérei: 1972-ben az ''Intel 8008'' (8 bites), 1974-ben az ''Intel 8080'', ami már ~0,5 MIPS teljesítményű, általános célú processzor volt. Ezek a mikroprocesszorok alapozták meg a személyi számítógépek létrejöttét. 1973-ban '''Robert Metcalfe''' és csapata a Xerox PARC-ban megalkotta az ''Ethernet'' technológiát, amely olcsó kábelek segítségével tette lehetővé számítógépek helyi hálózatba kötését. Az Ethernet hamar szabvánnyá vált és a későbbi lokális hálózatok (LAN-ok) gerincévé nőtte ki magát – ez is a ’70-es évek újítása. Ugyancsak 1973-ban '''Vinton Cerf és Robert Kahn''' elkezdték kidolgozni a ''Transmission Control Protocol'' (TCP) elődjét, ami az internethálózatok összekapcsolását tette lehetővé, megszületett az „internet protokollok” alapja. A tárolás terén is voltak jelentős újdonságok: 1971-ben az IBM bevezette az ''8 hüvelykes floppy lemezt'' adatcserére. Ez a hajlékony mágneslemez új, kényelmes módját kínálta a programok és adatok tárolásának és terjesztésének. 1979-ben megjelent a ''kompaktlemez (CD)'' prototípusa is – a Philips és a Sony kifejlesztette a digitális optikai adattárolás technológiáját, igaz a kereskedelmi CD csak 1982-ben debütált audió formátumban. A ’70-es évek közepén megszületett a '''személyi számítógép''' fogalma. 1975 januárjában a Popular Electronics magazin címlapján bemutatkozott a ''MITS Altair 8800'' számítógép, amely egy otthoni építésű készlet formájában volt kapható, és az Intel 8080 mikroprocesszoron alapult. Az Altair 8800 hatalmas siker lett a hobbyisták körében, és több ezer darabot adtak el belőle – sokan ezt tekintik az első PC-nek. Az Altair sikerén felbuzdulva 1975-ben '''Bill Gates''' és '''Paul Allen''' megírták az Altair BASIC tolmácsot, majd megalapították a '''Microsoftot''' a mikroszámítógépes szoftverek fejlesztésére. 1976-ban '''Steve Jobs és Steve Wozniak''' elkészítették az ''Apple I'' számítógépet (majd 1977-ben az Apple II-t), amely már készen összeszerelt formában, billentyűzettel és monitorral együtt kínált egy könnyebben használható személyi gépet. 1977 a személyi számítástechnika „szentháromságának” éve lett: piacra került az ''Apple II'', a ''Commodore PET'' és a ''Radio Shack TRS-80'' – három egymással versengő, de egyaránt népszerű személyi számítógép, melyek megalapozták az otthoni és irodai számítógép-forradalmat. <span id="hardverrendszerek-és-processzorok-3"></span> === Hardverrendszerek és processzorok === A mikroprocesszorok forradalma alapjaiban változtatta meg a számítógépek hardverfelépítését. Az 1970-es években sorra jelentek meg az új processzorok: az '''Intel 8080''' (1974) és ennek versenytársai, a '''Motorola 6800''' (1974) és a '''MOS Technology 6502''' (1975). A MOS 6502 különösen nagy hatású lett, mivel mindössze $25-ba került, így beépítették számos korai személyi számítógépbe (Apple II, Commodore PET, Atari konzolok stb.). A 8 bites processzorok generációja a ’70-es évek végére ért csúcsra: 1978-ban az Intel kiadta az ''8086'' processzort (16 bites belső felépítéssel, de 1979-ben piacra dobták 8 bites buszú változatát, az ''8088''-at is). Az Intel 8086/8088 processzorra épült később az IBM PC, de erről bővebben a ’80-as években. 1979-ben a Motorola is bemutatta a ''68000''-es processzort (16/32 bites architektúra), amely a következő években az Apple Macintosh és sok más gép motorja lett. A '''szuperszámítógépek''' terén is folytatódott a verseny. 1976-ban '''Seymour Cray''' megépítette a ''Cray-1'' vektorszámítógépet, amely 80 MFLOPS teljesítményével a világ leggyorsabb gépe lett. A Cray-1 innovatív, ''vektorprocesszoros'' kialakítást alkalmazott, mely lehetővé tette, hogy egy utasítással egész vektorsorozatokat dolgozzon fel – ezzel ideális volt tudományos szimulációkhoz (pl. időjárás-előrejelzés, aerodinamikai számítások). A Cray-1 elegáns, C-alakú formaterve és hűtőpadként funkcionáló „ülőkéje” ikonikus megjelenést kölcsönzött a szuperszámítógépek új generációjának. A memória és háttértár kapacitás robbanásszerűen nőtt: a ''félvezető memóriák'' (RAM chipek) kiszorították a ferritmag-tárakat. 1970-ben az Intel bemutatta az első DRAM chipet, az 1103-at, amely 1 kilobit tárolására volt képes. Ez aprónak tűnik, de ezekből a chipekből modulokat építve néhány kilobájt már megbízhatóan rendelkezésre állt a mikro- és miniszámítógépekben. A merevlemezek is egyre elterjedtebbek lettek: az 1970-es évek közepén egy tipikus miniszámítógép már ''Winchester'' merevlemezzel (néhány tíz megabájtos kapacitással) érkezett. 1979-ben a '''Seagate''' kihozta az első 5,25 hüvelykes winchester merevlemezt PC-khez (5 MB kapacitással), megalapozva a PC-k belső merevlemezeit. A ''számítógépes architektúrák'' terén a ’70-es évek végére kibontakozott a '''RISC''' (Reduced Instruction Set Computer) filozófia csírája. 1975-ben az IBM 801 prototípussal és a később induló Berkeley RISC projekttel kezdték vizsgálni, hogy egy egyszerűsített utasításkészletű processzor magas órajelen hatékonyabban működhet. Bár a RISC processzorok tömegpiaci megjelenése a ’80-as évekre esik, a koncepció alapjai már a ’70-es években formálódtak. <span id="operációs-rendszerek-3"></span> === Operációs rendszerek === A 1970-es években az operációs rendszerek a mainframe-ektől a személyi gépekig minden szintén jelen voltak. Az IBM nagygépein futó '''OS/360''' továbbfejlődött (megjött a virtuális memóriát támogató változat, az OS/VS), ezzel párhuzamosan megjelentek a gyártó-specifikus mainframe OS-ek (pl. DEC TOPS-10 a PDP-10 gépeken, ICL VME az ICL mainframe-eken stb.). A miniszámítógépek világában a '''Digital Equipment Corporation''' kifejlesztette a ''RT-11'' és ''RSTS/E'' rendszereket a PDP gépcsaládhoz, illetve 1977-ben a ''VMS'' operációs rendszert a VAX gépeihez. A VMS (Virtual Memory System) egy 32 bites virtuális memóriás, időosztásos OS volt, kifejezetten a nagyteljesítményű mini- és szuperszámítógépek igényeire szabva. Talán az évtized legfontosabb operációs rendszer eseménye a '''UNIX térhódítása'''. A ’70-es évek elején a Bell Labs UNIX rendszere elterjedt a tudományos intézményekben, különösen miután 1973-ban a UNIX-ot C nyelven újraírták, és az AT&amp;T kedvezményes licenc alatt hozzáférhetővé tette egyetemeknek. 1975-re számos egyetem futtatott UNIX-ot PDP-11 gépeken, és kialakult a UNIX közösség. A UNIX egyszerűsége és hordozhatósága (köszönhetően a C nyelvnek) előrevetítette, hogy a különböző számítógéptípusokon is egységes operációs rendszer futhat – ez akkoriban forradalmi gondolat volt a sok gyártó-specifikus OS mellett. 1978-ra a UNIX már eljutott a Version 7-hez, amely tartalmazta a pipe-okat, sok mai parancs elődjét és az első hálózati kommunikációs eszközöket (UUCP). A '''személyi számítógépek''' megjelenése új operációs rendszereket hívott életre. 1977-ben a Commodore, az Apple és a Tandy gépei még jellemzően beépített BASIC interpreterrel indultak és kazettáról vagy lemezről betöltött alkalmazásokat futtattak, de hamar igény lett valamilyen lemezkezelő rendszerre. 1976-ban '''Gary Kildall''' megírta a ''CP/M'' operációs rendszert a 8 bites mikrokomputerekhez. A CP/M egyszerű parancssoros OS volt, amely lemezfájlrendszert és alapszintű programbetöltést biztosított a Z80 és 8080 alapú gépek számára. A ’70-es évek végére a CP/M vált a de-facto szabvánnyá a mikrogépek között – számtalan szoftver készült rá, és ezt tekinthetjük az MS-DOS elődjének is. A grafikus felhasználói felület gondolata is megszületett a ’70-es években, bár még nem vált kereskedelmi valósággá. A '''Xerox PARC''' kifejlesztette a ''Alto'' számítógépet 1973-ban, amelyen egy primitív grafikus operációs környezet futott (ikonokkal, ablakokkal és egér támogatással). Az Alto sosem került piacra, de 1979-ben az Apple meglátogatta a PARC-ot és inspirációt merített a grafikus interfészből – ebből született meg majd az Apple Lisa (1983) és a Macintosh (1984) operációs rendszere. Így bár a ’70-es években a hétköznapi felhasználó még nem találkozott grafikus operációs rendszerrel, a laborokban és kutatóközpontokban már létezett ez a koncepció. <span id="programozási-nyelvek-és-fejlesztői-eszközök-3"></span> === Programozási nyelvek és fejlesztői eszközök === Az 1970-es évek folyamán tovább bővült a programozási nyelvek palettája. 1970-ben '''Niklaus Wirth''' publikálta a '''Pascal''' nyelvet, amely az ALGOL örökségét vitte tovább egyszerűbb és tanulhatóbb formában, kifejezetten az oktatás és a struktúrált programozás igényeire szabva. A Pascal rövidesen népszerű lett az egyetemeken, majd a ’80-as évek PC-s környezetében is (Turbo Pascal formájában). 1972-ben megszületett a '''C nyelv''' ('''Dennis Ritchie'''), amelyet eredetileg a UNIX rendszer implementálására terveztek a Bell Labs-nál. A C hordozhatósága és hatékonysága miatt gyorsan terjedni kezdett a különféle platformokon, és a ’70-es évek végére számos szoftver (nem csak UNIX) készült már C-ben. A C nyelv bevezette a mai alacsony szintű, de mégis magas szintű nyelvek (közvetlen memóriacímzés, mutatók, strukturált típusok) alapvető eszköztárát, és hatása szinte minden későbbi nyelvben tetten érhető. 1972 egy másik jelentős nyelv születését is látta: '''Prolog''' (Franciaországban '''Alain Colmerauer''' és kollégái). A Prolog a ''logikai programozás'' nyelve, elsősorban mesterséges intelligencia, szakértői rendszerek terén használták. Újszerű volt, hogy deklaratív módon, szabályok és tények formájában kellett benne a problémát megfogalmazni, és a megoldást a logikai következtető motor kereste meg – ez teljesen más paradigmát jelentett a hagyományos imperatív nyelvekhez képest. 1975 körül a '''strukturált programozás''' és a szoftverfejlesztés módszertanai kezdtek beérni. Ekkor jelentek meg az első ''moduláris programozás'' támogatására szolgáló nyelvek, mint például a '''Modula''' (Wirth, 1977) vagy az '''Ada''' (amit az amerikai Védelmi Minisztérium megbízásából 1979-ben kezdtek fejleszteni '''Jean Ichbiah''' vezetésével, és 1983-ra készült el). Az Ada nyelv kifejlesztését éppen a ’70-es évek végén felismert szoftverválság motiválta: egy olyan egyesített, erős típusellenőrzésű nyelvet akartak, amely a nagy katonai szoftverprojektekben használható. 1979-ben be is jelentették az Ada első verzióját. A '''fejlesztői eszközök''' terén a ’70-es évek újdonságai közé tartozott a verziókezelés és a debug technikák fejlődése. 1972-ben az '''Bell Labs''' kifejlesztette az első széles körben használt verziókövető rendszert, a ''SCCS''-t (Source Code Control System), hogy nagy szoftverprojektek forráskódját kezelni tudják verziók és párhuzamos fejlesztések mentén. A ''make'' eszköz 1976-ban jelent meg a UNIX világban (Stuart Feldman), automatizálva a szoftverfordítás lépéseit. A ’70-es évek végére a programozók rendelkezésére álltak a modern fordítóprogramok (a C compiler, Pascal compiler stb.), linkerek, és egyre jobb szövegszerkesztők (a Unix ''vi'' editor 1976-ban készült el, a ''Emacs'' szövegszerkesztő első verziója pedig 1976-ban jelent meg '''Richard Stallman''' jóvoltából). A ’70-es években a '''szoftverfejlesztés''' kezdett ipari méreteket ölteni, és ezzel együtt megjelentek az első integrált fejlesztői környezetek (IDE-k) csírái is. Például a UCSD Pascal rendszer (1978) egy komplett fejlesztői környezetet biztosított Pascal nyelvhez, saját operációs rendszerrel, virtuális géppel (P-code) – előrevetítve a Java VM elvét. <span id="alkalmazási-területek-3"></span> === Alkalmazási területek === Az 1970-es évekre a számítógépek '''meghódították az ipart, az irodákat és az otthonokat''' is (legalábbis az évtized végére). A '''nagyvállalati informatikában''' standarddá váltak a relációs adatbázis-kezelők, amelyek elméleti alapjait '''E. F. Codd''' fektette le 1970-ben. A ’70-es évek második felében az IBM és más cégek kifejlesztették az első relációs adatbázis-kezelő prototípusokat (System R, Ingres), és 1979-ben a '''Oracle''' kiadta az első kereskedelmi relációs adatbázis-kezelőt. Ez forradalmasította az üzleti adatok tárolását és lekérdezését, az SQL nyelv szabvánnyá vált. Az '''irodai alkalmazások''' az évtized végén születtek meg a személyi számítógépeken. 1978-ban jelent meg az első elektronikus táblázatkezelő program, a ''VisiCalc'', Apple II gépeken futott és sokak szerint ez volt az első „gyilkos alkalmazás” (killer app), amely miatt emberek tömegesen vásároltak személyi számítógépet. A VisiCalc lehetővé tette pénzügyi tervek, költségvetések interaktív kalkulációját, amivel forradalmasította a könyvelést. Hasonló áttörés volt a szövegszerkesztés: bár kezdetben a számítógépes szövegszerkesztés inkább nagygépeken történt (pl. a UNIX ''roff/nroff'' programjaival), 1979-ben megjelent a MicroPro '''WordStar''' CP/M gépekre, ami az első széles körben használt PC-s szövegszerkesztő lett. A '''mérnöki tervezésben''' (CAD – Computer-Aided Design) is megjelentek a számítógépek: az 1970-es évek közepén az autó- és repülőgépipar elkezdte használni a grafikus munkaállomásokat (pl. az IBM és a Dassault Systèmes által fejlesztett CATIA elődjei) a tervrajzok digitalizálására és szerkesztésére. A '''tudományos számítások''' területén a szuperszámítógépek egyre nehezebb feladatokat oldottak meg: meteorológiai modellek, molekuláris dinamika szimulációk és nukleáris fegyver-szimulációk futottak a Cray-1 és az azt követő gépeken. 1979-ben a Los Alamos laborban felállították az első Cray-1 gépet, ami lehetővé tette addig elképzelhetetlen részletességű számítások végzését. A '''hálózatépítés''' is felgyorsult: 1977-re az ARPANET hálózat már átszelte az Egyesült Államokat, és csatlakozott hozzá néhány európai csomópont is. 1978-ra az e-mail vált az ARPANET „gyilkos alkalmazásává” – a felhasználók többsége a levelezést használta leggyakrabban. Az elektronikus levelezés feltalálása '''Ray Tomlinson''' nevéhez fűződik, aki 1971-ben küldött először e-mailt két ARPANET gép között, és ő vezette be a ''@* szimbólumot is az e-mail címekben. A ’70-es évek végére már listák és hírlevél-szerű csoportos e-mailek is léteztek, sőt 1979-ben '''Tom Truscott és Jim Ellis''' létrehozták a ''Usenet* hírcsoport rendszert, amely az internet előtti fórumok, közösségi terek prototípusának tekinthető. A '''szórakoztató elektronika''' robbanása is erre az időre tehető. 1972-ben megjelent a ''Pong'' videojáték arcade változata, megalapítva a videojáték-ipart. 1977-ben debütált az '''Atari 2600''' játékkonzol a MOS 6502 leszármazottját tartalmazó CPU-val – ez a konzol tette otthoni hobbivá a videojátékot. 1978-ban a japán ''Space Invaders'' videojáték által kiváltott „játékgép-őrület” mutatta, hogy a számítógépek új területe a szórakoztatás lett. A számítógépes játékok a PC-kre is megérkeztek: 1978-ban jelent meg az ''Adventure'' (Colossal Cave) szöveges kalandjáték PDP-10-re, és 1979-ben az ''Aknafedő'' (Microsoft Adventure) PC-re, majd 1980-ban a Rogue – mind a későbbi játékstílusok előfutárai. <span id="fontos-idézetek-és-koncepciók-3"></span> === Fontos idézetek és koncepciók === A ’70-es évek számos emlékezetes mondást és koncepciót adott a számítástechnika történetéhez. 1975-ben a ''Homebrew Computer Club'' egyik levelében '''Bill Gates''' nyílt levélben ostorozta a hobbi programozókat azzal a felütéssel, hogy ''„nyílt levél a hobbistákhoz”'' – ebben sérelmezte, hogy az Altair BASIC értékes programját sokan fizetség nélkül másolják, és ezzel a szoftverfejlesztők megélhetését veszélyeztetik. Ez a levél a '''szoftver tulajdonjog''' viták korai dokumentuma, és előrevetítette a későbbi szoftverlicencelési modellek fontosságát. 1977-ben '''Ken Olsen''', a DEC alapítója hírhedten kijelentette: ''„Nincs semmi ok, amiért bárki is akarna számítógépet az otthonában”''. Ezt a korabeli gondolkodást jól tükröző idézetet később sokat emlegették téves jövőbelátás példájaként, hiszen pár éven belül a személyi számítógépek robbanásszerűen terjedni kezdtek. Olsen valójában a ’70-es évek végének helyzetére utalt, amikor a PC-k még kezdetlegesek voltak és kevés gyakorlati hasznot hoztak egy átlagember számára – de a technológia gyorsan rácáfolt a szavaira. '''Grace Hopper''' egy másik, humorosabb kontextusú idézete is erre az időszakra esik: gyakran mutogatta a 30 centiméter hosszú vezetéket, mondván ''„ez itt egy nanosec”'', utalva arra, hogy a fény vagy az elektromos jel kb. 30 cm-t tesz meg egy nanomásodperc alatt. Ezzel érzékeltette a fiatal programozóknak a számítógép belső sebességét és a késleltetések jelentőségét. A '''„gyilkos alkalmazás” (killer app)''' fogalma szintén a ’70-es évek végén született meg, amikor a VisiCalc kapcsán használták először: arra utalva, hogy egyetlen alkalmazás (jelen esetben a táblázatkezelő) képes egész platformok sikerét meghatározni, mert a felhasználók csak emiatt megveszik a szükséges hardvert. Ez a koncepció később is gyakran előjött (pl. a ’80-as években a desktop publishing a Macintosh esetében). <span id="nyílt-problémák-és-versenyek-3"></span> === Nyílt problémák és versenyek === A 1970-es években a technológiai fejlődés felvetett néhány új nyílt problémát is. Az egyik ilyen a '''kompatibilitás''' és '''szabványosítás''' kérdése. Ahogy egyre több cég gyártott mikroprocesszorokat, perifériákat és írt operációs rendszereket, fennállt a veszélye, hogy ezek egymással nem lesznek kompatibilisek. A ’70-es évek végén indult meg a szabványosítási törekvés: 1977-ben létrejött az '''IEEE''' számára a ''POSIX'' szabvány kezdeménye (bár hivatalosan csak ’80-as években standardizálták), a mikroszámítógépek világában pedig az '''S-100 busz''' (az Altair busza) és a CP/M operációs rendszer de-facto szabvánnyá vált a kompatibilitás érdekében. De kérdéses volt, hogy meddig tartható fenn az a helyzet, hogy szinte minden cég saját platformot épít – ez a nyílt probléma a ’80-as évekre a ''„platformháborúk”'' formáját öltötte (pl. PC vs. Apple vs. Commodore). A '''szellemi tulajdon és szoftverlicencelés''' is nyitott kérdés volt. Gates említett levele rávilágított arra, hogy a szoftvereket addig hajlamosak voltak az emberek ingyenes mellékterméknek tekinteni, míg a fejlesztők már komoly munkát fektettek beléjük. Ez a probléma a ’80-as években éleződött ki jogi viták formájában (pl. IBM PC BIOS klónok, Microsoft vs. Apple „look-and-feel” per). A ’70-es évek végére ugyanakkor egy ellentétes mozgalom csírája is megjelent: '''Richard Stallman''' 1976-77 körül kezdett elégedetlen lenni a szoftverek egyre zártabbá válásával és 1983-ban elindította a ''GNU Projektet'', de ennek előzményei a ’70-es évek közepére vezethetők vissza (pl. amikor a MIT AI lab nyomtatója szoftveréhez nem kapott forráskódot, Stallman elvi ügyet csinált belőle). Tehát a nyílt forráskódú szoftver és a proprietáris szoftver ellentéte már felütötte fejét, bár igazi versengéssé a ’80-as években vált. A '''versenyek''' terén a ’70-es évek két fontos vonulatot hoztak: a programozói és mesterséges intelligencia versenyeket, valamint a kereskedelmi piaci versenyt. 1970-ben tartották az első ACM által szervezett számítógépes sakkbajnokságot New Yorkban – ez az esemény a számítógépek közti versengés egyik első formális megnyilvánulása. 1974-ben aztán az első ''Világ Számítógépsakk Bajnokságot'' is megrendezték Stockholmban, ami azt mutatja, hogy a nemzetek (és vállalatok) már akkor is presztízskérdést csináltak az AI ezen ágából. A ’70-es évek végén, 1977-ben elindult az '''ACM Nemzetközi Programozóversenye (ICPC)''' is, kezdetben egyetemi csapatok számára, bár igazán nagy nemzetközi eseménnyé a ’80-as évekre nőtte ki magát. A kereskedelmi versenyben az '''IBM vs. a „közösség”''' jelentett sajátos nyílt kérdést. Az IBM mainframe-ek dominanciáját sokan meg akarták törni: 1975-ben az ''IBM antitröszt per'' még zajlott (1969-ben indították az USA-ban és csak ’82-ben zárult le). Közben a személyi számítógép piacon új szereplők bukkantak fel és kérdés volt, ki nyeri a ''„PC-háborúkat”''. A ’70-es évek végén még nyitott volt, hogy a Tandy/Apple/Commodore hármasból ki kerül ki győztesen – végül egyikük sem közvetlenül, hanem az IBM 1981-es belépése és a nyílt PC platform lett a meghatározó. De 1979-ben ezt még nem lehetett látni; Steve Jobs pl. egy 1979-es interjúban azt mondta: ''„Az IBM nem tudja megcsinálni, amit mi”'', utalva arra, hogy úgy vélte, az IBM túl merev a személyi számítógép piac gyors innovációihoz – ami részben igaz is volt, de az IBM mégis nyerni tudott a nyílt architektúra stratégiájával. Összegzésképpen a ’70-es évek a számítástechnika történetében az innováció és az új lehetőségek évtizede volt. A mikroprocesszor és a PC megjelent, az internet csírái kifejlődtek, a szoftveripar pedig önálló lábra állt. A nyílt problémák és versenyek a technológia további fejlődésének irányát is kijelölték, így előkészítve a terepet a robbanásszerű ’80-as éveknek. <span id="as-évek-személyi-számítógép-forradalom-és-az-internet-hajnala"></span> == 1980-as évek – Személyi számítógép-forradalom és az internet hajnala == <span id="találmányok-és-első-használatok-4"></span> === Találmányok és első használatok === Az 1980-as években a '''számítógépek tömegcikké váltak'''. 1981. augusztus 12-én az IBM bemutatta az ''IBM PC''-t (IBM 5150), egy nyílt architektúrájú személyi számítógépet, melynek tervét részben más cégek alkatrészeire építette. Az IBM PC hatalmas siker lett: már a megjelenés évében 100 000 rendelést vettek fel rá, és az IBM által teremtett platform (az Intel 8088 processzor és a Microsoft PC DOS operációs rendszer kombinációja) gyorsan ipari szabvánnyá vált. Mivel az IBM PC architektúrája „nyílt” volt (a buszok és interfészek dokumentáltak, az alkatrészek beszerezhetők), hamar megjelentek az ''IBM PC kompatibilis'' klónok is olyan gyártóktól, mint a Compaq, Dell, AST stb. Ez a nyílt megközelítés biztosította a PC hosszú távú dominanciáját. 1984 januárjában az '''Apple''' bemutatta a ''Macintosh'' számítógépet, amely az első széles körben elterjedt '''grafikus felhasználói felületű (GUI)''' számítógép lett. A Macintosh egérrel vezérelt ablakaival, ikonjaival és menüivel forradalmasította a felhasználói élményt. Bár nem ez volt az első GUI-s gép (előzte az Apple Lisa 1983-ban és a Xerox Alto kísérleti jelleggel), a Mac volt az, amelyet kereskedelmileg sikeresen árusítottak, viszonylag megfizethető $2500 körüli áron. Az 1984-es híres Macintosh reklám („1984”) a személyi számítógép mint a kreativitás eszköze szimbólumává vált. A Mac-hez alapcsomagként érkezett a MacPaint grafikus program és a MacWrite szövegszerkesztő, demonstrálva a WYSIWYG szerkesztés (amit látsz, azt kapod) előnyeit a grafikus környezetben. A játékipar és otthoni számítógépek terén is fontos találmányok születtek: 1983-ban a '''Nintendo''' kiadta Famicom játékkonzolját Japánban (ami 1985-ben NES néven Amerikában is megjelent), új életet lehelve a videójáték-piacba az 1983-as videojáték-ipari válság után. A ''8-bites mikrogépek'' (C64, ZX Spectrum, Apple II stb.) korszaka az évtized közepéig tartott, majd átadta helyét a ''16-bites otthoni számítógépeknek'': 1985-ben került piacra a '''Commodore Amiga 1000''' és az '''Atari ST''', melyek fejlett multimédiás képességeik (színpompás grafika, többcsatornás hang) révén népszerűek lettek az otthoni felhasználók és a játékosok körében. Az Amiga különösen úttörő volt: grafikus operációs rendszere multitaskingra volt képes és olyan programokat futtatott, amelyekkel a felhasználók zenét szerezhettek, videót digitalizálhattak (pl. NewTek Video Toaster, bár ez utóbbi a ’90-es évek elején), és persze kiváló játékplatform is volt. <span id="hardverrendszerek-és-processzorok-4"></span> === Hardverrendszerek és processzorok === Az évtized elején a meghatározó processzorok a 8 és 16 bites architektúrák voltak. Az '''Intel 8086/8088''' (16 bites belső – 8 bites külső buszú változattal) dominált a PC-knél, de 1982-ben megjelent az '''Intel 80286''' (286) processzor, amely már 24 bites címbusszal 16 MB memóriát is megcímezhetett, és védett módot vezetett be, megalapozva a többfeladatos operációs rendszerek PC-s jövőjét. Az IBM AT gépben (1984) már 80286-os CPU volt, kihasználva e teljesítménytöbbletet. 1985-ben jött az '''Intel 80386''' – egy valódi 32 bites processzor, amely óriási előrelépést jelentett: 4 GB címzési tartomány, beépített memóriavédelmi mechanizmusok és viszonylag magas (16-33 MHz) órajelek. A 80386 lehetővé tette a „nagy” operációs rendszerek futtatását PC-n (pl. UNIX variánsok), és 1986-ban a Compaq már piacra dobta az első 386-os PC-t (megelőzve az IBM-et). Ez mutatja, hogy a PC-platformon belül is éles verseny zajlott a gyártók közt. Az évtized végén, 1989-ben megjelent az '''Intel 80486''' processzor, integrált matematikai társprocesszorral és ~1,2 millió tranzisztorral, mely 25 MHz-en ~20 MIPS teljesítményt nyújtott. A 486 már olyan integrációs szintet képviselt, hogy alaplapra forrasztva komplett PC-k „agya” lehetett, külön lebegőpontos koprocesszor nélkül. A rivális CPU-k közül a '''Motorola 68000''' család a Macintoshokban és sok munkaállomásban (pl. Sun-3) hódított. 1984-ben a Motorola bemutatta a ''68020''-at (32 bites, 20 MHz), 1987-ben a ''68030''-at (25 MHz, integrált MMU) és 1989-ben a ''68040''-et (ami már integrált FPU-val is rendelkezett, és 33 MHz-en ~4,5 MIPS-re volt képes). Ezek a CISC architektúrák versengtek az Intel x86 vonalával a számítógépekben – a Macintosh II 1987-ben 68020-ra épült, a Macintosh IIfx 1990-ben pedig 40 MHz-es 68030-ra. A ''RISC forradalom'' is beindult: 1986-ban a '''HP''' kihozta az első saját RISC processzorait (PA-RISC), 1987-ben a '''Sun Microsystems''' a SPARC architektúrát, 1989-ben az '''MIPS''' a R3000-es processzort. Ezek a RISC CPU-k kevesebb tranzisztorral magas órajeleket és hatékony számítási teljesítményt értek el a munkaállomások és szuperszámítógépek terén. Bár a PC-k világában a RISC csak a ’90-es években (PowerPC, DEC Alpha) bukkant fel, az évtized végére már látható volt, hogy a RISC architektúrák kihívást intézhetnek a CISC (x86, 68k) dominancia ellen. A '''tárkapacitások''' is rohamosan nőttek: a memóriamodulokban a ’80-as évek eleji tipikus PC még 64-256 kB RAM-mal jött, de a 640 kB (''„640K ought to be enough”'' – híresen Bill Gates-nek tulajdonított mondás) határt hamar kinőtték, és a késő ’80-as évek AT számítógépeiben már 1-4 MB RAM sem volt ritka. A merevlemezek kapacitása megugrott: az évtized elején egy PC winchester 10 MB körüli volt, 1985-re 20-40 MB, 1989-re pedig megjelentek az 100-200 MB-os meghajtók is az asztali gépekben. 1984-ben az IBM bemutatta az első ''1 gigabájtos'' lemeztárat, igaz ez még egy hűtőszekrény méretű eszköz volt. Az optikai tárolás is valósággá vált: 1982-ben piacra került az Audio CD, majd 1985-ben a CD-ROM (650 MB tárhellyel), noha a CD-ROM meghajtók csak a ’90-es években terjedtek el a PC-kben (az első PC-s CD-ROM meghajtók 1988 körül jelentek meg). A '''perifériák''' terén a ’80-as évek egyebek mellett a lézeres nyomtatást hozta el: az '''HP''' 1984-ben mutatta be az első ''LaserJet'' nyomtatót, ami a később irodai standarddá vált gyors és minőségi nyomtatást tette lehetővé. A '''grafikus megjelenítés''' is hatalmasat lépett: 1981-ben az IBM CGA (színes grafikus adapter) 4 színt tudott egyszerre, 320×200 felbontásban. 1984-ben jött az EGA (16 szín, 640×350), majd 1987-ben a VGA (256 szín, 640×480, sőt emlékezetes 320×200-as módban 256 színű „MCGA”). 1989-ben pedig a VESA (Video Electronics Standards Association) megalakult és megalkotta a VESA BIOS kiterjesztést a grafikus kártyák egységes kezelésére. A PC-s grafika fejlődése megalapozta a későbbi gazdag multimédiát. <span id="operációs-rendszerek-4"></span> === Operációs rendszerek === Az 1980-as évek a '''személyi számítógépek operációs rendszereinek''' berobbanását hozták. Az IBM PC 1981-ben a ''PC DOS 1.0''-val érkezett (amit a Microsoft szállított MS-DOS néven más klónokra is). Az MS-DOS a ’80-as évek első felében a PC-k meghatározó OS-e lett: parancssoros, egyfelhasználós, egyszerre csak egy programot futtató rendszer volt, de a hardver egyszerűsége miatt gyors és folyamatosan fejlődött. 1983 márciusában kijött az ''MS-DOS 2.0'', amely már al-mappákat (könyvtárakat) is támogatott a fájlrendszerben. Az MS-DOS uralma egészen 1995-ig tartott a fogyasztói PC-ken, bár idővel grafikus felülettel kombinálták. A grafikus felületek a PC világban is megjelentek: 1985 novemberében a '''Microsoft kiadta a Windows 1.0'''-t, ami az MS-DOS-ra épülő grafikus héj volt (korlátozott multitaskinggal, ikonokkal, ablakokkal). Bár a Windows 1.0 és a 1987-es 2.0 még nem volt átütő siker, megalapozta a Microsoft későbbi grafikus rendszereit. Az Apple Macintosh viszont már 1984-től komoly GUI-s operációs rendszerrel rendelkezett (System 1.0, majd System 6-ig jutott a ’80-as évek végén), amely könnyű használatával és grafikus képességeivel népszerű volt a desktop kiadványszerkesztésben. ''„Look and feel” per'' zajlott az Apple és Microsoft között, mivel az Apple úgy vélte, a Windows 2.0 túlzottan lemásolta a Mac felületét – a jogvita végül 1997-ig húzódott és peren kívüli megegyezés lett belőle, amikor az Apple ejtette a vádat. A '''hálózati operációs rendszerek''' is megjelentek: 1983-ban a '''Novell''' kiadta a ''NetWare'' rendszerét, amely PC alapú szervereken futva lehetővé tette fájl- és nyomtatómegosztást helyi hálózatokon. A Novell NetWare a ’80-as évek második felében de-facto szabvánnyá vált a PC hálózatokban. A '''UNIX''' szintén hódított: a ’80-as évek elején megjelentek az első kereskedelmi UNIX verziók (Xenix – a Microsoft saját UNIX-a 1980-ban, majd a AT&amp;T UNIX System V 1983-ban). Az AT&amp;T feloldotta a korábbi licenckötöttségeket, így a UNIX a vállalati miniszámítógépektől a mainframe-eken át a munkaállomásokig mindenhová beférkőzött. 1982-ben a '''Sun Microsystems''' megalakulásakor a UNIX-ot választotta munkaállomásain (SunOS/BSD variáns), 1983-ban az AT&amp;T UNIX System V kiadása egységesíteni próbálta a különböző UNIX ágazatokat. A ’80-as évek végére azonban már UNIX „háború” bontakozott ki a különböző gyártói verziók között (Xenix, SCO, SunOS, HP-UX, AIX, etc.), míg másik oldalon a közösség 1983-ban elindította a ''GNU projektet'', egy szabad UNIX-klón megalkotására. 1985-ben megalakult a '''Free Software Foundation''' Stallman vezetésével, ami a szabad operációs rendszer és szoftverek fejlesztését koordinálta – a ’80-as években a GNU sok eszközt (fordítókat, szerkesztőket) készített el, de a kernel hiányzott; ennek megoldására 1991-ig kellett várni (Linux megjelenése). A '''szuperszámítógépek és mainframe-ek operációs rendszerei''' is fejlődtek: az IBM 1988-ban mutatta be az MVS utódját, a ''ESA/370'' architektúrát futtató ''MVS/ESA''-t mainframe-jein; a Cray szuperszámítógépek saját COS operációs rendszert futtattak, majd Unicos néven UNIX-alapú rendszert. A felhő-előd ''„hálózat, mint számítógép”'' koncepció pedig 1984-ben kapott hangot '''John Gage''' (Sun) híres mondásában: ''„The network is the computer.”'' – utalva arra, hogy a SUN gépek hálózatba kötve egy nagy erőforrásként működhetnek. <span id="programozási-nyelvek-és-fejlesztői-eszközök-4"></span> === Programozási nyelvek és fejlesztői eszközök === Az ’80-as években a programozási nyelvek terén a '''struktúrált, moduláris és objektumorientált''' szemlélet erősödött meg. 1983-ban jelent meg hivatalosan az '''Ada''' nyelv első verziója (Ada 83), amelyet a védelmi iparban és repülésben kezdtek alkalmazni biztonságkritikus szoftverekhez. 1985-ben '''Bjarne Stroustrup''' publikálta a '''C++ nyelv''' első hivatalos kiadását (a „C with Classes” kísérleti nyelvből kinőve). A C++ a C nyelv hatékonyságát ötvözte az objektumorientált programozás lehetőségeivel, így hamar népszerű lett a kereskedelmi szoftverfejlesztésben. A ’80-as évek végére a C++ már számos platformon elérhető volt, és kezdte felváltani a klasszikus C-t nagy szoftverprojektekben. A '''funkcionális programozás''' is kapott egy lökést: 1984-ben megjelent a '''Miranda''' nyelv az egyetemeken (David Turner), ami a későbbi Haskell nyelv előfutára volt. Bár a funkcionális nyelvek (Lisp, ML, Scheme, Miranda) inkább akadémiai körökben maradtak, hatásuk a nyelvelméletre és később a gyakorlati nyelvekre is (lambda kifejezések, magasabbrendű függvények) tetten érhető. A '''BASIC''' nyelv továbbfejlődött az otthoni számítógépekben: szinte minden mikrogéphez saját BASIC változat járt (Commodore BASIC, GW-BASIC, AppleSoft BASIC stb.). 1985-ben a Microsoft kiadta a ''QuickBASIC''-et PC-re, ami már szerkesztőfelülettel és fordítóval segítette a BASIC programozókat. A '''szoftverfejlesztő eszközök''' terén a ’80-as évek nagy újítása a '''visual''' (vizuális) fejlesztői környezetek megjelenése. 1988-ban a Microsoft kiadta a ''Visual Basic'' elődjét jelentő ''QuickBasic Extended''-et (QuickBASIC 4.5), majd 1991-ben jött a Visual Basic maga, de ennek alapjai a ’80-as évek végi integrált környezetekre nyúlnak vissza. A '''Turbo Pascal''' (Borland) 1983-as megjelenése forradalmasította az IDE fogalmát PC-n: a szerkesztő, fordító és futtató integrálva, villámgyors fordítással tette lehetővé a fejlesztést – a Turbo Pascal és később Turbo C, Turbo C++ a fejlesztők széles körében népszerű eszköz lett. A '''verziókezelés''' szélesebb körű használata is az ’80-as években terjedt el: a Unix világban 1986-ban megjelent a ''RCS'' (Revision Control System), majd 1990-ben a ''CVS'' (Concurrent Versions System) – ezek lehetővé tették nagy szoftverprojektek kódbázisának egyidejű kezelését több fejlesztő között. A '''hálózati programozás''' is új eszközöket kapott: 1984-ben a BSD Unix 4.2 bevezette a ''sockets API''-t, ami a hálózati kommunikáció de-facto sztenderdjévé vált, és amelyen keresztül készült el sok internetes szoftver (FTP, SMTP, etc.). 1989-re pedig a Tim Berners-Lee által javasolt ''World Wide Web'' protokollok (HTTP, HTML) kidolgozása megkezdődött – ez még nem programozási nyelv, de új ''jelölőnyelv'' (HTML) és ''átviteli protokoll'' (HTTP) születését jelentette, melyeket a ’90-es évek programozói már bőszen használtak webfejlesztéshez. <span id="alkalmazási-területek-4"></span> === Alkalmazási területek === Az 1980-as években a számítástechnika mindennapivá válása gyökeresen átalakította az alkalmazási területeket. '''Otthon és oktatás''': A személyi számítógépek – ZX Spectrum, Commodore 64, Apple II, IBM PC és klónjaik – tömegesen elterjedtek az otthonokban és iskolákban. Ezáltal a gyerekek és felnőttek milliói találkoztak először számítógéppel, általában játék vagy tanulás céljából. Az oktatásban megjelent az informatika mint tantárgy, és a diákok BASIC-ben programoztak iskolai mikrogépeken. Az '''irodai munka''' radikális átalakuláson ment át a PC-k és szoftvercsomagok révén. 1983-ban a ''Lotus 1-2-3'' program (Lotus Development Corporation) egyesítette a táblázatkezelést, grafikonrajzolást és alapszintű adatbázis-kezelést egy MS-DOS alkalmazásban – ez a program az üzleti világban az IBM PC egyik húzóalkalmazása lett, a VisiCalc utódaként. A szövegszerkesztés terén a WordStar (1981) mellett 1983-ban a '''Microsoft Word''' (DOS-ra) és 1985-ben a '''Aldus PageMaker''' (Macintoshra) megjelenése kiemelhető. A PageMaker és az Apple LaserWriter nyomtató (PostScript-alapú) párosa lehetővé tette az ''asztali kiadványszerkesztést (desktop publishing)'', ami addig drága szedőgépeket igényelt. Ennek eredményeként kis kiadók, irodák is készíthettek nyomdai minőségű anyagokat – az 1985-ös Mac + LaserWriter + PageMaker triumvirátust sokan a DTP forradalom kezdetének tartják. A '''hálózatok és kommunikáció''' robbanása is az évtizedhez köthető: 1983. január 1-jén az ARPANET hivatalosan átállt a TCP/IP protokollra – ezt tekinthetjük az internet születésnapjának. Innentől kezdve gyorsulni kezdett a hálózat bővülése. 1985-ben létrejött az NSFNET az USA-ban, ami az egyetemeket kapcsolta össze nagy sávszélességű gerinchálózattal, felváltva fokozatosan az ARPANET-et. 1988-ra nemzetközi méretű, TCP/IP-t használó hálózat alakult ki (ekkor csatlakozott Magyarország is először egy email átjárón keresztül, majd 1990-ben teljes értékűen). A ’80-as években ugyan az „internet” még főként tudományos intézmények eszköze volt, de már ~100 000 számítógép csatlakozott rá, és ekkor jelentek meg az első internetes szolgáltatások a nagyközönség számára: pl. 1989-ben indult a ''PSINet'' mint az első kereskedelmi internet-szolgáltató (ISP) az USA-ban. Az e-mail ekkorra már az üzleti életben is mindennapossá vált, legalábbis a technológiai szektorban – 1982-ben meghatározták az SMTP protokollt szabványként. 1988 novemberében azonban figyelmeztetést is kapott az internet közössége: a ''Morris-féreg'' vírusfertőzés átmenetileg megbénította a hálózat jelentős részét, mintegy 6000 gépet megfertőzve a ~60 000-ből, ezzel történelmi első nagy internetes támadásként vonult be. A Morris-féreg ráirányította a figyelmet a hálózati biztonság kérdésére, és közvetve hozzájárult a CERT megalakulásához 1988-ban az incidenskezelés koordinálására. A '''szórakoztatóipar''' és média digitalizációja is felgyorsult. A filmekben megjelent a számítógépes grafika: 1982-ben a ''Tron'' film úttörő módon használt CGI jeleneteket, 1984-ben a ''The Last Starfighter'' teljes egészében számítógéppel generált űrcsatát tartalmazott. 1986-ban a '''Pixar''' kiadta az első teljesen számítógéppel animált rövidfilmet (''Luxo Jr.''), jelezve hogy a rajzfilm-animációban is itt a digitális kor. A zenei világban a digitális szintetizátorok és a ''MIDI szabvány'' (1983) lehetővé tették különböző eszközök összekapcsolását és számítógéppel vezérelt zeneszerzést. A hangrögzítés is áttért digitális formátumokra: 1982-ben a CD bevezetése, 1987-ben az első ''MP3'' algoritmus prototípus (a végleges szabvány 1993-ban jött ki). A '''videójátékok''' a ’80-as években hatalmas iparággá váltak: a Nintendo és Sega konzolok milliók otthonába jutottak el, míg a PC-k és otthoni számítógépek is platformot biztosítottak ezerféle játéknak. 1984-ben jelent meg a máig híres ''Tetris'' (Alekszej Pazsitnov), 1985-ben a ''Super Mario Bros.'', 1989-ben a ''SimCity'' és a ''Prince of Persia'' – hogy csak néhány meghatározót említsünk. A játékok fejlődése hajtotta a grafikushardver és a hangkártyák fejlődését is: 1989-ben a '''Creative Labs''' kiadta az első ''Sound Blaster'' hangkártyát, ami szabvánnyá tette a PC-kben a polifonikus hangokat és digitális audiólejátszást. <span id="fontos-idézetek-és-koncepciók-4"></span> === Fontos idézetek és koncepciók === Az 1980-as évek számos szállóigéje közül néhány örökre beégett az informatika történetébe. 1981-ben, amikor az IBM PC megjelent 640 kB maximális konvencionális memóriával, Bill Gates-nek tulajdonítottak egy kijelentést: ''„640K mindenkinek elég kell legyen”''. Gates később többször cáfolta, hogy ezt szó szerint így mondta volna, de a mondás elterjedt, mint a számítástechnikai jóslatok kudarcának jelképe – a szoftverek ugyanis pár éven belül meghaladták ezt a memóriaigényt. 1983-ban az '''Apple''' bemutatkozó reklámfilmje (rendezte Ridley Scott) a szürke diktatúra elleni lázadó nővel az IBM-et mint ''„Big Brother”''-t ábrázolta, és azt sugallta, hogy ''„1984” nem úgy lesz, ahogy Orwell megírta, mert jön a Macintosh, ami felszabadítja a számítástechnikát”''. A reklám végén hangzik el: ''„És megtudod, miért nem lesz 1984 olyan, mint 1984”''. Ez a spot egy korszak reklámkultúrájának ikonja, és az Apple küldetéstudatát fejezte ki. 1985-ben, a Microsoft Windows indulásakor '''Steve Jobs''' azzal vádolta a Microsoftot, hogy ''„nincs bennük eredetiség”'', mire állítólag '''Bill Gates''' így válaszolt: ''„Steve, azt hiszem, hogy mindketten egy gazdag szomszéd Xerox gépházába törtünk be, hogy ellopjunk egy tévét, csak te előbb értél oda és azt mondod, én loptam el tőled”''. Ez a csípős megjegyzés utal arra a köztudott tényre, hogy mind az Apple, mind a Microsoft merített ötleteket a Xerox PARC fejlesztéseiből a grafikus felület kapcsán. Gates ezzel kvázi elismerte, hogy a GUI alapötlete nem az Apple-é és nem is a Microsofté, hanem a Xeroxé – de a lopás metaforával érzékeltette a versengést is kettejük közt. '''Andy Grove''', az Intel vezérigazgatója mondta 1983-ban: ''„Csak a paranoiások maradnak fenn”'' („Only the paranoid survive”), utalva ezzel arra, hogy az állandó versenyben a folyamatos éberség és újítás képessége a kulcs – ez a mondás később könyvcímként is híressé vált, és a Szilícium-völgy cégkultúrájának mottója lett. 1989-ben, amikor a World Wide Web ötlete megszületett '''Tim Berners-Lee''' fejében, sokan kétkedtek. Akkoriban hangzott el a vélemény néhány tudóstól: ''„Ki akarhatná az egész világot behálózó hypertextet használni? Kinek van erre ideje?”''. Ez inkább utólag feljegyzett anekdota, de jól mutatja, hogy még az internetes forradalom küszöbén sem látta mindenki előre a változás mértékét. <span id="nyílt-problémák-és-versenyek-4"></span> === Nyílt problémák és versenyek === Az 1980-as években számos nyílt probléma konkretizálódott, melyek megoldása a következő évtizedek feladata lett. Az egyik ilyen a '''számítógép-hálózatok összekapcsolása''' globális méretekben. Bár a TCP/IP megszületett és az internet növekedett, nyitott kérdés volt a skálázódás (a címek, routing kérdései – amit később az IPv6, BGP protokoll stb. oldott meg részben), valamint a hozzáférés demokratizálása: a ’80-as évek végén az internet még főleg egyetemi és kutatóhálózat volt, a nagy nyitás 1989-1990-ben indult, de a hogyan és miként sok szempontból nyitott volt. A '''szoftverek komplexitása''' tovább nőtt, és bár a struktúrált és objektumorientált módszerek segítettek, a ''„szoftverválság”'' még nem múlt el. 1986-ban '''Fred Brooks''' kiadott egy híres esszét ''„No Silver Bullet”'' (Nincs csodafegyver) címmel, amelyben kifejtette, hogy nincs egyetlen varázsmódszer vagy eszköz, ami tízszeres javulást hozna a szoftverfejlesztés termelékenységében. A ’80-as évek végére ezért még mindig nyílt problémaként állt, hogyan lehet megbízható, nagy szoftverrendszereket határidőre és költségvetésen belül szállítani. Erre a válaszok (pl. formális módszerek, fejlett fejlesztői eszközök, később agilisan moduláris metodológiák) a későbbiekben érkeztek. A '''szellemi tulajdon''' és ''„look-and-feel”'' viták is nyitott kérdések maradtak. Az Apple vs. Microsoft per egészen 1997-ig húzódott (végül megegyeztek: Microsoft befektetett az Apple-be, cserébe az Apple ejtette a pert). Közben a nyílt forráskódú mozgalom erősödött: 1989-ben kiadták a '''GNU General Public License''' (GPL) 1.0 verzióját, ami a szabad szoftverek jogi keretét teremtette meg. A zárt vs. nyílt szoftverek versenye és együttélése egyre inkább a figyelem középpontjába került, de egyelőre a zárt forrású szoftver dominanciája nyilvánvaló volt (Microsoft ekkorra a szoftveripar óriásává nőtt, az FSF pedig még csak a fundamentumokat rakta le). A '''piaci verseny''' extrémen kiélezett volt: a PC-piacon 1987-88-ra a tajvani klóngyártók és a Compaq vezette olcsóbb klónok kiszorították az IBM-et a vezető pozícióból – nyitott kérdés volt, az IBM tudja-e tartani vezető szerepét (nem tudta). Az Apple a Mac sikeres rajtja után 1985-ben belső konfliktus miatt elvesztette Steve Jobs-ot (akit eltávolítottak a cégből), és a késő ’80-es évekre az Apple piaci részesedése stagnált, majd csökkenni kezdett, nyitva hagyva a kérdést, túléli-e a cég a következő évtizedet (ez 1997-98 körül vált kritikus kérdéssé, mire Jobs visszatért). A mikroprocesszoroknál az '''Intel vs. Motorola vs. RISC''' háború körvonalazódott: nyitott volt, hogy a RISC architektúrák átveszik-e a vezetést. A ’80-as évek végén úgy tűnt, a RISC munkaállomások (Sun, SGI, IBM) technikai fölényben vannak a PC-kkel szemben, de nyitott maradt, hogy ez a fogyasztói piacon is megjelenik-e (végül a PC vonal maradt domináns x86-tal, a RISC pedig az 1990-es években inkább a beágyazott és mobil szegmensben hódított, lásd ARM). A '''mesterséges intelligencia''' újabb reneszánsza is a ’80-as évekhez köthető: az ún. ''„második AI nyár”'' időszaka volt ez, különösen a szakértői rendszerek térnyerése miatt. Vállalatok dollár százmilliókat öltek olyan AI rendszerfejlesztésbe, ami speciális problémákat oldott meg (pl. orvosi diagnosztika, hitelbírálat). Nyitott maradt azonban, hogy ezen rendszerek mennyire skálázhatók és általánosíthatók – a válasz az lett, hogy a legtöbb szakértői rendszer csak szűk területen működik jól, és az AI ismét átmeneti csalódást okozott a 80-as évek végére. A szélesebb értelemben vett mesterséges intelligencia, különösen a neurális hálózatok, 1986-ban újra előtérbe kerültek (Rumelhart és McClelland munkái a visszaterjesztés algoritmusáról), de gyakorlati sikerük még váratott magára a korlátozott számítási kapacitás miatt. Versenyek terén a ’80-as években '''nemzetközi diákolimpiák''' is indultak: 1989-ben tartották meg az első '''Nemzetközi Informatikai Diákolimpiát (IOI)''' Bulgáriában, jelezve, hogy a programozási versenyek már a középiskolás szintre is kiterjedtek világszerte. Az ACM ICPC is növekedett és 1989-ben már 30+ ország egyetemi csapatai vettek részt. Az '''AI versenyek''' közül a számítógépes sakkban 1988-ban az IBM Deep Thought programja megnyerte a világbajnokságot és kihívta Kaszparovot (1989-ben játszottak is, Kaszparov még nyert; Deep Thought utódja lett a ’90-es évek Deep Blue-ja). Emellett 1980 óta évente megrendezték a Loebner-díjat a Turing-teszt jellegű beszélgető AI-knak – ezek show-jellegű versenyek voltak, melyeket egyik program sem nyert meg meggyőzően (és máig nem nyert „teljes Turing-tesztet” senki). Az '''1980-as évek''' végére a számítástechnika világa elképesztően kitágult, de ezzel új kihívások érkeztek. A ''hidegháború vége'' (1989) nyomán a korábban katonai célú internet megnyílt a civil szféra felé, megteremtve az 1990-es évek dot-com korszakának alapjait. A PC-k mindenhol ott voltak, de a szoftverek és hardverek interoperabilitása, a szabványok harca és a felhasználói igények kielégítése folyamatos versenyt diktált a cégeknek. Az évtized nyitott kérdései, – hogyan integráljuk globálisan a hálózatokat, hogyan kezeljük a növekvő szoftverkomplexitást, hogyan védjük meg az adatokat és rendszereket – közvetlenül vezettek a következő évtized technológiai irányaihoz. <span id="es-évek-az-internet-és-a-multimédia-forradalma"></span> == 1990-es évek – Az internet és a multimédia forradalma == <span id="találmányok-és-első-használatok-5"></span> === Találmányok és első használatok === A 1990-es évek központi találmánya kétségtelenül a '''Világháló (World Wide Web)''' volt. 1990 végén '''Tim Berners-Lee''' a CERN-ben elkészítette a WorldWideWeb nevű első böngészőt és webszervert, miután 1990. november 12-én beadott javaslatában használta először a „World Wide Web” kifejezést. 1991 augusztusában a web nyilvánossá vált az interneten: Berners-Lee közzétette a WWW leírását és forráskódját nyíltan, ami lehetővé tette, hogy bárki futtasson webszervert és fejlesszen böngészőt. A web feltalálása egyesítette a hypertext koncepcióját az internet protokolljaival, és rövidesen hatalmas lendületet adott az internet elterjedésének. 1993-ban jelent meg az '''NCSA Mosaic''' böngésző, az első széles körben használt grafikus web-böngésző, Marc Andreessen és csapata jóvoltából. A Mosaic népszerűsége miatt 1994-től a web forgalma exponenciálisan nőni kezdett. 1994-ben '''Netscape''' (Andreessen új cége) kiadta a Netscape Navigator böngészőt, amely a ’90-es évek közepének domináns böngészőjévé vált. A web mellett számtalan internetes technológia született: 1991-ben indult a '''Gopher''' (egy menürendszeres internetes információkereső protokoll) – bár a web hamar túlnőtt rajta, a Gopher újdonsága jelezte az online információelosztás igényét. 1998-ban jelent meg a '''Google''' kereső (először Stanford-projektként), amely forradalmasította a weben való keresést intelligens PageRank algoritmusával. A számítógépes hardverben a ’90-es évek hozta el a '''gigahertz határának''' megközelítését: 1993-ban az Intel kiadta a ''Pentium'' processzort (P5 mikroarchitektúra), ami 60/66 MHz-en futott, de az évtized végére, 1999-re az Intel Pentium III már 500 MHz felett járt, az '''AMD''' Athlon pedig 750 MHz-nél. 2000-ben (közvetlenül az évtized végén túl) lépte át először kereskedelmi CPU az 1 GHz-et (AMD Athlon, majd Pentium III). A mikroprocesszoroknál nyílt kérdés volt a hőtermelés és órajel-skálázás, amit egy darabig a félvezető csíkszélességek csökkentése megoldott. A '''tárolástechnika''' ugrásszerű fejlődést mutatott: a merevlemezek kapacitása a 90-es években a megabájtos tartományból gigabájtossá nőtt. 1991-ben az első 3,5”-os 1 GB-s HDD megjelent, 1998-ra már 10-20 GB-os merevlemezek voltak a PC-kben. A CD-ROM a ’90-es évek elején rohamosan elterjedt mint szoftverterjesztési és adattárolási médium. 1995-ben a '''DVD''' formátum szabványosodott (és 1997-től jelentek meg a DVD-lejátszók, PC-s DVD-ROM-ok), ami 4,7 GB kapacitást nyújtott optikai lemezen, megnyitva az utat a digitális videó és nagy szoftverek terjesztése előtt. A 90-es években a '''mobileszközök''' is kezdték integrálni a számítástechnikát: 1992-ben az IBM bemutatta az ''IBM Simon'' személyi kommunikátort, amit az első okostelefonnak tekintenek (a funkciói közt e-mail, fax, naptár is volt). Bár kereskedelmileg nem lett átütő siker, a Simon jelezte a jövőt. 1996-ban megjelent a '''Palm Pilot''' kéziszámítógép, ami a PDA-k (Personal Digital Assistant) korszakát indította el. Ezek a zsebgépek korlátozottak voltak, de naptár, címtár, jegyzetek kezelésére és némi szinkronizálásra használták őket – a mobil számítástechnika csírái. <span id="hardverrendszerek-és-processzorok-5"></span> === Hardverrendszerek és processzorok === Az évtized elején a processzorpiacot az '''Intel''' uralta a Pentium sorozattal. 1995-ben megjelent a ''Pentium Pro'' (P6 architektúra), amely a szerverek és munkaállomások piacát célozta, és újdonságként a processzorlapkára integrált másodszintű cache-t tartalmazott. A Pentium Pro 200 MHz-es csúcssebességével és 5,5 millió tranzisztorával a csúcsteljesítményt képviselte a maga idejében. 1997-ben az Intel kiadta a ''Pentium II''-t, amely a Pentium Pro magját kombinálta multimédiás kiterjesztésekkel (MMX) – ezzel a PC-k már jobban boldogultak grafikával, hanggal, videóval. 1999-ben a ''Pentium III'' is megjelent (Katmai mag 450–600 MHz-en), SSE utasításkészlettel a 3D grafika gyorsítására. Az '''AMD''' mint versenytárs a ’90-es években erősödött meg: 1999-ben kihozták az ''Athlon'' processzort (K7 architektúra), amely 500–750 MHz között futott és sok tekintetben felülmúlta az azévi Pentium III-at. Az AMD Athlon volt az első komoly kihívója az Intelnek a csúcsteljesítmény terén, megelőlegezve a 2000-es évek CPU „óraszámháborúit”. A '''RISC architektúrák''' a munkaállomásokban és szerverekben érték el csúcspontjukat: a Sun SPARC, SGI MIPS, IBM POWER, HP PA-RISC processzorcsaládok mind új generációkkal jöttek ki. 1995-ben az '''IBM és Motorola''' közösen piacra dobta a ''PowerPC 604e'' processzort, ami a Macintoshokban és IBM munkaállomásokban futott, 350 MHz körüli órajelekkel. A DEC 1992-ben bemutatta az ''Alpha'' 64 bites RISC processzort, ami éveken át a világ leggyorsabb CPU-jának számított órajelenkénti műveletekben. Az Alpha 1996-ban már 500 MHz-en járt, messze megelőzve az Intel órajeleit akkoriban. Ezzel együtt a RISC vs CISC vita is lezárult abban az értelemben, hogy mindkét oldal közeledett egymáshoz: az Intel P6 architektúra belsőleg már mikro-utakra törte a CISC utasításokat (dynamikus utasításfordítás), míg a RISC chip-ek egyre több tranzisztort kezdtek használni cache-re és speciális funkciókra, nem csupán „egyszerűek” voltak. Végső soron az x86 vonal maradt a PC-knél domináns, de a RISC architektúrák integrálódtak a beágyazott rendszerekbe és később a mobil eszközökbe. A '''perifériák''' és buszrendszerek terén is jelentős fejlesztések történtek. 1993-ban az Intel bevezette a ''PCI buszt'', ami leváltotta az ISA/EISA buszokat a PC-ben, lényegesen nagyobb átviteli sebességet és plug-and-play konfigurációt kínálva. 1997-ben megjelent az ''AGP port'' a grafikus kártyák számára, dedikált sávszélességet adva 3D grafikának. 1996-ban a '''USB 1.0''' szabvány megszületett (az első széles elterjedése 1998 körül, USB 1.1 formájában történt), ami egységesítette a csatlakozófelületet a billentyűzet, egér, nyomtató, kamera stb. számára. A '''grafikus gyorsítás''' a PC-ben óriásit lépett: 1996-ban a 3dfx cég kiadta a ''Voodoo Graphics'' 3D gyorsítókártyát, ami forradalmasította a PC-s játékok megjelenítését. Ezzel kezdetét vette a GPU-k (Graphics Processing Unit) felemelkedése. 1999-ben az NVIDIA piacra dobta a ''GeForce 256'' GPU-t, amelyet az első ''„GPU”''-ként marketingeltek, mivel tartalmazott hardveres transzformációs és világítási (T&amp;L) egységet. Ez lehetővé tette, hogy a bonyolult 3D számításokat (mátrixtranszformációk, fénymodellek) a videókártya végezze, felszabadítva a CPU-t – a modern grafikus számítási paradigma kezdete. <span id="operációs-rendszerek-5"></span> === Operációs rendszerek === A 90-es évek elején a PC-k többségén még '''MS-DOS''' futott, gyakran grafikus felülettel (Windows 3.0/3.1) kiegészítve. 1990 májusában a Microsoft kiadta a ''Windows 3.0''-t, amely az első széles körben sikeres Windows verzió lett, multitask módon futtatva több DOS programot a 386-os processzor védett módját kihasználva. A Windows 3.0 és a rá következő 3.1 (1992) már valódi fenyegetést jelentett a Macintosh számára, mert egyre több felhasználó váltott át a hasonló képességeket kínáló, de olcsóbb PC platformra. <ol start="1995" style="list-style-type: decimal;"> <li>augusztus 24-én aztán megérkezett a ''Windows 95'', amely 32 bites, preemptív multitasking operációs rendszer volt, integrált grafikus felülettel, és maga mögött hagyta a régi 640 KB limitet. A Windows 95 hatalmas marketingkampány kíséretében debütált, és percek alatt elfogyott az üzletekből. Beépítve tartalmazta az akkor új '''Internet Explorer 1.0''' böngészőt is (melyet a Plus! csomagban lehetett külön telepíteni, majd Windows 95 OSR2.5-től integráltan jött). A Windows 95 egyesítette a DOS/Windows vonalakat egyetlen termékbe, és megkönnyítette a felhasználók számára az internet csatlakozást is (bár az igazi integráció a Windows 98-ban történt).</li></ol> A '''Macintosh''' vonalon az Apple 1991-ben kiadta a ''System 7''-et, egy továbbfejlesztett, színes GUI-s operációs rendszert, amely memóriavédelmet ugyan még nem nyújtott, de multitaskingot és sok új funkciót igen. Az Apple azonban egyre inkább lemaradt az OS-fejlesztésben a 90-es években; a Copland nevű teljesen újraírt OS projektjük kudarcot vallott, és végül 1997-ben az Apple úgy döntött, külső forrásból szerzi be új generációs OS-ét – megvásárolták '''NeXT''' vállalatot, amellyel Steve Jobs visszatért, és a NeXTSTEP alapjain építették fel a későbbi Mac OS X-et (de ez már 2001-ben jelent meg, a 90-es évek végén folyt a fejlesztése). A '''UNIX származékok''' erősen jelen voltak a szervereken és munkaállomásokon. 1991-ben azonban egy új szereplő lépett színre: '''Linus Torvalds''' finn hallgató bejelentette, hogy hobbiból fejleszt egy szabad operációs rendszermagot a PC-jére – ez lett a ''Linux kernel''. Az 1991. augusztus 25-i híres Usenet üzenet így kezdődött: ''„Hello mindenki… Egy (szabad) operációs rendszeren dolgozom (csak hobbi, nem lesz nagy és profi, mint GNU) 386(486) AT klónokra”''. Torvalds 1991 őszén publikálta a Linux 0.01 kódját, és 1994 márciusában kiadta az első hivatalos stabil változatot, a ''Linux 1.0''-t. A Linux a ’90-es évek közepén robbanásszerűen fejlődött, köszönhetően a GNU projekt által biztosított szoftvereszközöknek és a nemzetközi közreműködői közösségnek. 1999-re a Linux kernel 2.2-es verziója jelent meg, és becslések szerint több mint 10 millió felhasználó futtatott Linuxot világszerte, főleg szervereken és technikai környezetben. A Linux a nyílt forráskódú mozgalom diadalának számított, és a dot-com éra internetes infrastruktúrájának kulcselemévé vált (webszerverek, DNS szerverek, stb. gyakran Linuxon futottak). A '''Windows NT''' vonal is elindult: 1993-ban a Microsoft kiadta a ''Windows NT 3.1''-et, egy teljesen 32 bites, üzleti szerverekre és munkaállomásokra szánt OS-t (Dave Cutler vezetésével, VMS alapelvekre építve). Ez a vonal a 90-es évek végére találkozott a fogyasztói vonallal: 1996-ban jött a Windows NT 4.0 (amely Windows 95-szerű felületet kapott), majd 2000-ben a Windows 2000 – utóbbi már egyesítette a felhasználói és vállalati Windows vonalat NT alapon, kvázi a Windows 95/98 utódjaként is működött. A '''hálózati operációs rendszerek''' terén a Novell NetWare uralma a ’90-es években fokozatosan csökkent, ahogy a Microsoft 1996 után megjelent a Windows NT Server termékcsaláddal, integrált tartománykezeléssel (Active Directory 1999-ben készült el). A nyílt szabványok is tért nyertek: 1998-ban jelent meg a ''Samba'' szerver, ami lehetővé tette, hogy UNIX/Linux gépek Windows hálózatokban fájl- és nyomtatómegosztást végezzenek, ezzel nyitott forrású alternatívát kínálva a Windows szerverfunkciókra. A '''kézi eszközök OS-ei''' is megjelentek: 1996-ban a Palm OS a PDA-kon, 1996-ban a Windows CE (későbbi Pocket PC, Windows Mobile) a kéziszámítógépeken. Ezek még kezdetlegesek voltak, de megalapozták a mobil operációs rendszerek fejlődését. <span id="programozási-nyelvek-és-fejlesztői-eszközök-5"></span> === Programozási nyelvek és fejlesztői eszközök === A 90-es években a programozási nyelvek terén két nagy trend volt: az '''objektumorientált programozás''' térnyerése a nagy projekteknél, és az '''internet/programozás''' új nyelveinek megjelenése. 1995 körül valóságos nyelvdömping történt: * '''Java''': 1995 májusában a Sun Microsystems bemutatta a Java nyelvet és platformot (eredetileg 1991-től „Oak” kódnéven fejlesztették). A Java mottója „Write Once, Run Anywhere” lett, utalva a virtuális gépre (JVM) épülő, platformfüggetlen bytecode végrehajtásra. A Java gyorsan népszerű lett a webes (appletek a böngészőben) és szerveroldali fejlesztésben egyaránt, mivel objektumorientált, biztonságos (pointerek nélküli), és gazdag standard könyvtárral rendelkezett. * '''JavaScript''': 1995-ben a Netscape cég kifejlesztette a JavaScript nyelvet (Brendan Eich munkája), amelyet a Netscape Navigator böngészőbe építettek be, hogy dinamikus interakciókat tegyen lehetővé weboldalakon. A JavaScript (eredetileg LiveScript) névválasztása marketingfogás volt, a nyelvnek kevés köze volt a Javához, viszont ez lett a szabványos kliens-oldali szkript nyelv a weben. 1996-ra a Microsoft is implementálta (JScript néven) az Internet Explorerbe, majd az EcmaScript szabvány 1997-ben formalizálta a nyelvet. * '''PHP''': 1995-ben '''Rasmus Lerdorf''' nyilvánosságra hozta a PHP/FI nevű egyszerű szkriptet CGI feladatokra, amelyből kinőtt a PHP nyelv. A PHP (PHP: Hypertext Preprocessor) kifejezetten webes szerveroldali programozásra készült, beágyazható HTML-be. 1998-ra a PHP3 verzió már széles körben használt volt dinamikus weboldalak létrehozására, köszönhetően az egyszerű szintaxisának és az ingyenes elérhetőségének. * '''Python''': bár a Python első verziója 1991-ben született ('''Guido van Rossum''' alkotása), a nyelv igazán a ’90-es évek második felében kezdett terjedni a programozók között, 1.5-ös verzió (1998) körül. A Python a tiszta, olvasható szintaxisával és sokoldalú standard könyvtárával a gyors fejlesztést igénylő területeken (szkriptek, adminisztráció, web) kedvelt nyelv lett. * '''Ruby''': 1995-ben Japánban '''Yukihiro Matsumoto (Matz)''' létrehozta a Ruby nyelvet, amely objektumorientált és script nyelv egyben, a Perl és Smalltalk inspirációival. Ruby nyugaton a ’90-es években még kevéssé volt ismert, de Japánban népszerű lett, és a 2000-es években a Ruby on Rails keretrendszer hozta meg nemzetközi sikerét. A „régi” nyelvek közül a '''C és C++''' továbbra is dominált a rendszerszintű és alkalmazásfejlesztésben. A Microsoft például 1992-ben kiadta a ''Visual C++'' fejlesztőkörnyezetet. Az '''object-oriented paradigm''' széles körű elfogadását jelzi, hogy 1990-ben az ISO/IEC szabványosította a C++ nyelvet, és a nagy szoftverek (operációs rendszerek GUI részei, irodai szoftvercsomagok stb.) gyakran C++-ban íródtak. Az '''adatbázis-kezelés''' terén a '''SQL''' nyelv vált ipari szabvánnyá (1986-ban az ANSI, 1987-ben az ISO szabványosította, majd jöttek bővítések a ’90-es években). Az Oracle, IBM DB2, Sybase, Microsoft SQL Server mind SQL alapú relációs adatbázisokat kínált, és 1995-ben megjelent a ''MySQL'' is nyílt forráskódú alternatívaként. A '''fejlesztői eszközök''' hihetetlen fejlődést mutattak. A 90-es évek volt a '''IDE-k virágkora''': Microsoft Visual Studio (1997-től integrált csomagként), Borland Delphi (1995-ben jelent meg, a Turbo Pascal utóda, vizuális komponens alapú fejlesztésre koncentrálva), Borland C++ Builder (1997). Ezek az eszközök WYSIWYG jellegű grafikus felület-tervezőkkel és erőteljes debuggerekkel könnyítették a fejlesztést. A '''forráskód-kezelő rendszerek''' nagyvállalati használatra is beértek: 1995-ben a Microsoft kiadta a ''Visual SourceSafe''-et, 1990-ben megjelent a CVS nyílt forráskódú verziója. A 90-es évek végén már a ''változatkövetés'' és ''bug tracking'' rendszerek használata bevett gyakorlat lett a szoftverfejlesztésben. A '''hálózatbiztonság és titkosítás''' is a programozási eszköztár részévé vált: 1995-ben publikálták a '''SSL''' protokollt (Secure Sockets Layer) a Netscape-nél, ami a webes forgalom titkosítását oldotta meg (elődje a mai TLS-nek). A nyilvános kulcsú titkosítás terén a '''PGP (Pretty Good Privacy)''' programot '''Phil Zimmermann''' 1991-ben tette közzé, hogy bárki használhasson erős titkosítást e-mailhez – ami miatt aztán évekig jogi csatákat vívott az amerikai hatóságokkal (akkoriban a titkosító algoritmusokat hadi exportcikknek minősítették). Végül a titkosítás széles körű használata győzött: 1999-ben az USA feloldotta a legszigorúbb exportkorlátozásokat, a böngészők és e-mail kliensek pedig natívan integrálták a titkosított protokollokat. <span id="alkalmazási-területek-5"></span> === Alkalmazási területek === A 90-es évek messzemenően átalakították a mindennapi életet a számítógépes technológia alkalmazása révén. A '''világháló''' megszületése és elterjedése új alkalmazási területeket nyitott: * '''Kommunikáció''': Az e-mail mellett megjelent a ''csevegés (chat)'' és az ''instant messaging''. 1988-ban a '''IRC (Internet Relay Chat)''' protokoll lehetővé tette a valós idejű szöveges beszélgetéseket csoportokban. 1996-ban indult az '''ICQ''', az első széles körben elterjedt instant üzenetküldő program, majd követte 1997-ben az AOL Instant Messenger és a Microsoft későbbi MSN Messenger (1999). Ezek valós időben kötötték össze a felhasználókat, a „szöveges beszélgetés” a neten mindennapossá vált. A 90-es évek végén a mobiltelefonok SMS üzenetküldése is robbanásszerűen népszerű lett, így a fiatal generációk gyakorlatilag folyamatos digitális kapcsolatban álltak egymással. * '''Információkeresés és portálok''': A web növekedésével szükség lett keresőmotorokra és webkatalógusokra. Az első generációs keresők (Archie, Veronica – még Gopherhez; majd WebCrawler, Lycos, AltaVista – webhez) mind a ’90-es évek közepén indultak. 1994-ben '''Jerry Yang és David Filo''' létrehozták a ''Yahoo!'' kézzel szerkesztett webkatalógust, ami portállá fejlődött. 1995-re a Yahoo, Excite, Lycos, Infoseek, AltaVista mind versengtek a weben információt keresők kegyeiért. A '''Google''' 1998-as indulásával a hatékonyság sokszorosára nőtt (PageRank alapú találatrendezés), és gyorsan a vezető keresővé vált. Ezzel új iparág, az ''SEO (Search Engine Optimization)'' is született, mert a cégek felismerték, milyen fontos, hogy weblapjaik előkelő helyen szerepeljenek a keresőkben. * '''Elektronikus kereskedelem''': A 90-es évek közepén megalakultak az első dot-com cégek, amelyek az internetet kereskedelmi célra használták. 1994-ben '''Jeff Bezos''' megalapította az ''Amazon.com''-ot könyvárusként – mára globális e-kereskedelmi óriás. 1995-ben '''Pierre Omidyar''' útjára indította az ''eBay'' online piacteret, amely lehetővé tette bárkinek, hogy aukciókon értékesítsen bármit világszerte. 1999-ben a kínai '''Jack Ma''' megalapította az ''Alibaba'' B2B portált. Ezen pionírok által az e-kereskedelem bebizonyította életképességét: az 1998-as karácsonyi szezonban az Amazon hatalmas forgalmat bonyolított, ezzel beírva az internetet a kiskereskedelem történetébe. Ugyancsak 90-es évek végi jelenség a ''dot-com boom'' – internetes startup vállalatok százai alakultak, a tőzsde eufóriával reagált (NASDAQ index szárnyalt 1995-2000 között). Olyan cégek születtek ebben az időben, mint a ''Paypal'' (1998 – online fizetés), a ''Napster'' (1999 – zene-megosztó, ami a zeneiparnak hívta fel a figyelmét a digitális terjesztésre), a ''Google'' (1998). * '''Szórakoztatás és média''': A 90-es évek végére a digitális tartalomfogyasztás előfutárai már léteztek. 1996-ban megjelent a ''DVD'', ami 2000-re kezdte leváltani a VHS kazettákat. A számítógépek CD-meghajtói révén a zenehallgatás és később a CD-írók révén a zene másolása, CD-írás széles körben elterjedt (és aggasztotta a kiadókat). 1999-ben a Napster elhozta az MP3 fájlmegosztás lázát – ugyan jogi okokból 2001-re be is zárták, de Pandora szelencéje kinyílt: a peer-to-peer (P2P) fájlmegosztás és a digitális zene kora elkezdődött. A ''videojáték-ipar'' is hatalmas üzletté vált: 1991-ben a Super Nintendo hódított, 1994-ben kijött a ''Sony PlayStation'', ami CD-alapú játékkonzolként új generációt nyitott (1999-re a PlayStation eladásai meghaladták a 100 milliót). 1998-ban jelent meg a ''Pokémon'' jelenség (GameBoy játék és anime, ami világszerte őrületet okozott). A PC-s játékok is virágoztak: 1993-ban a ''Doom'' és 1996-ban a ''Quake'' lerakta az online multiplayer FPS alapjait, 1998-ban a ''StarCraft'' és ''Half-Life'' új műfaji csúcsokat döntött. Az ''e-sport'' fogalma megszületett (1997 Red Annihilation Quake bajnokság, 1998 StarCraft versenyek Dél-Koreában). * '''Film és animáció''': 1995-ben a Pixar kiadta a ''Toy Story''-t, a világ első teljes egészében számítógéppel animált egészestés filmjét, bizonyítva, hogy a CGI képes érzelmes, élvezetes mozit alkotni – a film hatalmas kasszasiker lett. Ettől kezdve a digitális animáció fontos ága lett a filmgyártásnak, és a kézzel rajzolt animáció lassan visszaszorult. A speciális effektusok terén is a 90-es évek forradalmat hoztak: 1991-ben a ''Terminátor 2'' folyékony fém T-1000 karaktere (Industrial Light &amp; Magic CGI-jával) új mércét állított, 1993-ban a ''Jurassic Park'' dinoszauruszai számítógépes animációval keltek életre, 1999-ben a ''Mátrix'' film bullet time effektje és a Star Wars előzménytrilógia (I. rész) 3D karakterei (Jar Jar Binks) mutatták, hogy a CGI szinte mindent lehetővé tesz a filmvásznon. A '''tudomány és technika''' terén is a számítógépek immár nélkülözhetetlenné váltak. A 90-es években a '''szuperszámítógépek''' listáján Japán és az USA versengett: 1993-ban indult a TOP500 lista, melynek élén sokáig az amerikai Intel Paragon, majd az ASCI Red állt, de 1996-ban a japán NEC Earth Simulator is csúcsközelben volt. A tudományos számítások (időjárási modell, kozmológia, anyagtudomány) mind HPC rendszereken futottak. 1997-ben az IBM ''Deep Blue'' számítógép '''sakkozásban legyőzte Garri Kaszparov''' világbajnokot – ezzel beteljesítve a fél évszázados kihívást és sokak számára bizonyítva a számítógépek „intelligenciáját” a szűk területen. A biológiában 1990-ben indult a '''Humán Genom Projekt''', amely gigászi mennyiségű DNS-szekvencia adatait csak komoly számítógépes erővel tudta feldolgozni – 2000-re elkészültek az emberi genom első változatával. Az internet pedig a tudományos együttműködést is meggyorsította: megjelentek az elektronikus folyóiratok, e-print szerverek (pl. arXiv 1991-től) és a tudósok e-mailen, weben keresztül osztották meg eredményeiket, felgyorsítva a kutatás ütemét. <span id="fontos-idézetek-és-koncepciók-5"></span> === Fontos idézetek és koncepciók === A 90-es évek tele volt optimista és pesszimista jóslatokkal a digitalizációval kapcsolatban. '''Bill Gates''' 1995-ben adta ki „The Road Ahead” című könyvét, amelyben vizionálta a „mindenhol jelenlévő számítástechnika” (pervasive computing) jövőjét és a „műsorszórás és számítástechnika konvergenciáját”. '''Nicholas Negroponte''' 1995-ös „Being Digital” könyvében bevezette a ''„from atoms to bits”'' koncepciót, miszerint a fizikai termékek (atomok) digitális formába (bitek) alakulása alapvetően változtat meg iparágakat (zenét, filmet, könyvkiadást). E jóslatok határozottan igaznak bizonyultak. '''Larry Page és Sergey Brin''' (a Google alapítók) mondása 1998-ból: ''„A tökéletes keresőmotor megértené pontosan, mit gondolsz, és pontosan azt adná, amit akarsz”''. Ez a hitvallás vezette a Google fejlesztéseit (PageRank algoritmus stb.), és előre vetíti a későbbi mesterséges intelligenciával megtámogatott keresést, ami mára kezd valósággá válni. '''„dot-com boom”''': E kifejezést a 90-es évek végén kezdték használni a technológiai tőzsdei buborékra utalva. Az akkor szállóigévé vált mondás ''„Get Big Fast”'' (Növekedj nagyra, gyorsan) Jeff Bezos stratégiája volt az Amazonnál, de sok dot-com cég követte: a piaci részesedést fontosabbnak tartották a profitnál, bízva abban, hogy a győztes mindent visz. Ez a koncepció vegyes eredményekhez vezetett: sok cég összeomlott a dot-com lufi kipukkanásakor (2000-2001), de akik túlélték (Amazon, eBay, Google), valóban dominánssá váltak. '''1999, Y2K''': A ’90-es évek végén a legnagyobb nyilvános figyelmet kapott informatikai téma az ''Y2K-probléma'' volt. Sok régi szoftverben és adatbázisban ugyanis csak két számjeggyel tárolták az évszámot, így 2000-re átfordulva potenciálisan hibásan értelmezhették volna (1900 vagy 2000). Az egész világon nagy erőkkel fogtak neki a rendszerek Y2K kompatibilissé tételének. '''„Y2K compliant”''' és '''„Y2K bug”''' lett a kifejezés, amit a laikus közönség is megtanult. Végül a hatalmas összefogásnak hála 2000. január 1-jén nem történtek nagyobb katasztrófák – utólag egyesek túlzott hisztériának tartották az egészet, pedig inkább arról volt szó, hogy a megelőző munka meghozta gyümölcsét. '''„Információs szupersztráda”''': Ezt a kifejezést '''Al Gore''' amerikai szenátor (későbbi alelnök) népszerűsítette a ’90-es évek elején a globális szélessávú hálózatok víziójára. Az “Information Superhighway” metafora segített a nyilvánossággal megértetni az internet jelentőségét, és politikai támogatást gyűjteni a távközlési infrastruktúra fejlesztéséhez. '''GNU GPL''' és a '''„szabad szoftver”''': '''Richard Stallman''' híres mondása ''„A szabad szoftver nem (csak) azt jelenti, hogy ingyenes (free as in free beer), hanem hogy szabad, mint a szólásszabadság (free as in free speech)”''. Ez a 90-es évek során terjedt el, mert sok félreértés adódott a „free software” kifejezés miatt. Emellett Stallman a „copyleft” fogalmát is megalkotta – szójáték a copyrighttal, azokra a licencekre utalva, amelyek biztosítják a szabadságjogok továbböröklődését. <span id="nyílt-problémák-és-versenyek-5"></span> === Nyílt problémák és versenyek === A 90-es évek végére, bár rengeteg kérdést megoldottak, számtalan új nyílt probléma merült fel, amelyek a következő évtizedeket formálták. Az '''internet szabályozása és biztonsága''' nyitott problémaként jelent meg. A dot-com boom idején felmerült a netes kereskedelem szabályozása (pl. internetes adózás kérdése), az online tartalmak (pl. szerzői jogvédelem Napster ügy kapcsán), és a kibertérben elkövetett bűncselekmények (hackelés, vírusok, csalások) elleni fellépés. 1998-ban elfogadták az USA-ban a ''Digital Millennium Copyright Act'' (DMCA) törvényt, ami az online szerzői jogi védelem sarokköve lett, bár sok vita övezte (a hackelés elleni részei miatt is). 1999-ben történt az egyik első nagy '''DDoS támadás''' (az eBay, Amazon, Yahoo ellen 2000 elején, egy MafiaBoy nicknevű fiatal által), ami ráirányította a figyelmet a hálózat sebezhetőségére. A biztonság nyitott gond maradt: 1998-ban a '''CIH/Chernobyl vírus''' sok kárt okozott, 1999-ben pedig a '''Melissa számítógépes vírus''' e-mailek tömeges küldésével terjedt és zavart keltett. Ezek mind előrevetítették a 2000-es évek internetes biztonsági kihívásait (vírusjárványok, adathalászat, hacker csoportok). A '''szélessávú internet''' igénye is nyitott kérdés volt: a 90-es évek végén a legtöbb felhasználó még betárcsázós (dial-up) modemmel kapcsolódott (33.6k, majd 56k), ami szűkös sávszélt adott. Bár már létezett DSL technológia (az első ADSL szabvány 1998-ban), ennek kiépítése a telefontársaságok részéről csak most indult. Nyitott kérdés volt, mennyire gyorsan tudnak az infrastruktúrák lépést tartani az egyre sávszélesség-éhesebb alkalmazásokkal (pl. Napster). Hasonlóképp a vezeték nélküli hálózatok: az első ''Wi-Fi'' szabvány, az IEEE 802.11b 1999-ben jelent meg, de még csak 11 Mbit/s-el. A wifi, majd a mobil internet (GPRS, később 3G) a 2000-es évek témája lett, de magja a 90-es évek végén vetődött el. A '''mobil számítástechnika''' nyitottan hagyta, ki és hogyan integrálja a telekommunikációt a számítástechnikával. A 90-es évek végén a mobiltelefonok már digitális GSM hálózatokon terjedtek (SMS-sel, 1998-tól WAP böngészőkkel kísérleteztek, sikertelenül), a PDA-k pedig külön eszközként léteztek. A konvergencia – okostelefon, mobilinternet – még gyerekcipőben járt (bár 1999-ben a Japán NTT DoCoMo i-Mode szolgáltatása már mobilon netezést kínált). Nyitott kérdés maradt, hogy egyesül-e a kézben tartott telefon és a kézben tartott számítógép – a válasz a 2000-es években az iPhone és Android formájában jött. A '''dot-com buborék''' kipukkanása 2000 körül nyitva hagyta, mely internetes cégek élik túl, és milyen üzleti modellel lesz fenntartható egy online vállalkozás. 1999-2000-ben sok cég a „szemgolyó” (látogatottság) alapján értékelte magát, a profitra kevés fókuszt helyezve. A részvénypiac 2000 tavaszán bedőlt, sok cég csődbe ment. Azonban a túlélők (Amazon, eBay, Yahoo, és nem sokkal később a Google) bizonyították, hogy az internetes gazdaság létező dolog. A nyitott kérdés az volt, hogyan lehet fenntartható bevételt generálni online szolgáltatásokból – erre a késő 2000-es években a hirdetés-alapú modellek (Google AdWords 2000-ben, később Web 2.0, közösségi média monetizáció) adtak választ. A '''magánélet védelme''' és '''kriptográfia szabadsága''' is kiélezett lett. 1991-ben, amikor a PGP kijött, az USA hatóságai vizsgálatot indítottak ellene, de a nyilvánosság nyomása miatt ejtették. 1993-ban az amerikai kormány egy „Clipper chip” nevű, lehallgathatóságot biztosító titkosító csip standardot javasolt, ám ez erős ellenállásba ütközött a szakmai és civil jogi szervezetek részéről, és végül megbukott. 1998-ban a ''„természetes szövetségesek”'' csoport (EFF stb.) kivívta, hogy a kormány enyhítse a titkosítás exportkorlátozását. Mégis, a magánszféra vs. biztonság vs. üzleti érdekek közti egyensúly máig nyitott problémákat eredményez (lásd: cookie-k és adatvédelem, 1999-ben az EU először adott ki irányelvet a személyes adatok védelméről; spam e-mailek – a világ első anti-spam törvényei 2003-ban jöttek). A 90-es évek végén a spam már komoly gond volt (a teljes e-mail forgalom jelentős része kéretlen reklám volt), de hatékony megoldás még nem létezett rá. Összegzésképpen a 90-es évek a ''digitális forradalom'' kiteljesedését hozta, és átvezette a társadalmat az új évezredbe, ahol a számítástechnika és internet a gazdaság, kultúra és mindennapi élet alapinfrastruktúrájává vált. A megválaszolatlan kérdések és új kihívások pedig megalapozták a következő évtizedek technológiai fejlődését és vitáit. ----- Az ezredforduló utáni évtizedekben a számítástechnika drámai fejlődésen ment keresztül, amely gyökeresen átalakította a mindennapi életet és a gazdaságot. A 2000-es évek elejét a dotkom lufi kipukkadása jellemezte, amely számos internetes startup bukásához vezetett. Ugyanakkor az internet és a világháló tovább terjedt, és olyan online óriások erősödtek meg, mint az Amazon és az eBay, amelyek sikeresen vészelték át a piaci átrendeződést. A következő évtizedekben az információs technológia egyre inkább behálózta a társadalmat: megjelentek az okostelefonok, közösségi hálózatok és felhőszolgáltatások, miközben a számítógépek teljesítménye és az adatok mennyisége exponenciálisan nőtt. A 2010-es évekre a mobil eszközök váltak elsődleges számítástechnikai platformmá, a mesterséges intelligencia pedig kézzelfogható eredményeket kezdett felmutatni a mindennapokban. A 2020-as évekre a számítástechnika az élet szinte minden területén kulcsszerepet játszik – a járványhelyzet felgyorsította a digitális átállást, az AI pedig soha nem látott képességekkel jelentkezett. Az alábbiakban évtizedenként áttekintjük a számítástechnika történetének főbb fejleményeit 2000 után, tematikus bontásban, bemutatva a technológiai újításokat és azok társadalmi hatásait. <span id="es-évek"></span> == 2000-es évek == <span id="mesterséges-intelligencia"></span> === Mesterséges intelligencia === Bár a mesterséges intelligencia forradalma csak a következő évtizedekben bontakozott ki, a 2000-es években is történtek fontos előrelépések ezen a téren. Az MI ekkor főként kutatási terület maradt, de bizonyos feladatokban már ekkor kimagasló teljesítményt nyújtott. Például 2005-ben egy önvezető autó (Stanley, a Stanford Egyetem járműve) első ízben teljesített sikeresen egy közel 212 km hosszú sivatagi terepversenyt a '''DARPA Grand Challenge''' keretében. Az évtized során fejlődtek a gépi tanulási algoritmusok és a robotika is – többek között ilyen technológiák tették lehetővé az önvezető járművek kísérleteit. A korszak kutatásai megalapozták a későbbi ugrásszerű eredményeket, amelyek a 2010-es években váltak széles körben ismertté. <span id="hardver"></span> === Hardver === A 2000-es években a számítástechnikai hardver teljesítménye tovább nőtt, bár az évtized végére a hagyományos ütem (a Moore-törvény) lassulni kezdett, és előtérbe került a párhuzamos feldolgozás. 2000-ben jelentek meg az első 1 GHz órajelű processzorok (az AMD Athlon és a Pentium III). A számítógépes architektúrák ekkor tértek át fokozatosan a 64 bites címzésre: az AMD 2003-ban piacra dobta az első széles körben elérhető 64 bites PC-processzort (Athlon 64). A magas órajel miatti hőtermelés korlátai miatt a gyártók a többmagos processzorok felé fordultak: 2005-ben az Intel és az AMD egyaránt kiadták első kétmagos processzoraikat (Pentium D, ill. Athlon 64 X2). Fontos iparági váltás volt, hogy az Apple 2005-ben bejelentette: PowerPC helyett Intel processzorokra vált a Mac számítógépeiben; 2006-ban megjelentek az első Intel-alapú Macek is (például a MacBook Pro). A csúcskategóriás számítógépek terén új rekordok születtek: 2000-ben az IBM ASCI White szuperszámítógép 12,3 billió műveletet végzett másodpercenként, ezzel a világ leggyorsabbja lett, az évtized végére pedig az első petaflop (10^15 művelet/s) sebességű rendszer is üzembe állt. A grafikus hardver szintén ugrásszerűen fejlődött. 2004-ben az NVIDIA GeForce 6800 grafikus chip több mint kétszeresére növelte az előző generáció teljesítményét, megközelítve a filmes minőségű, valós idejű megjelenítést. A nagy felbontású optikai adathordozók versenyében a Blu-ray diadalmaskodott a HD DVD felett 2008-ban, ipari szabvánnyá válva. A személyi számítógépek hardvere diverzifikálódott ebben az évtizedben. A hordozható PC-k (laptopok) egyre elterjedtebbé váltak, megjelentek a kisméretű, olcsó '''netbookok''' is (ilyen volt a 2007-ben bemutatott Asus Eee PC mini-laptop). A videojáték-konzolok új generációi jelentek meg, amelyek addig példa nélküli számítási teljesítménnyel és grafikával érkeztek: a Sony PlayStation 2 (2000), a Nintendo GameCube (2001) és a Microsoft Xbox (2001), majd az évtized közepén az Xbox 360 (2005), a PlayStation 3 és a Nintendo Wii (mindkettő 2006). Közben a mobiltelefonok is egyre fejlettebbé váltak: megjelentek az első '''okostelefonok'''. 2000-ben dobták piacra az első, korlátozott internetképes telefont (Ericsson R380, Symbian operációs rendszerrel), 2002-ben pedig az első BlackBerry okostelefont, mely az üzleti e-mailezésben újított. 2007-ben az Apple bemutatta az első iPhone-t, az érintőképernyős, alkalmazásközpontú okostelefont, amely új irányt szabott a mobiltelefon-iparágnak. 2008-ban pedig megjelent az első Android rendszerű telefon is (HTC Dream), ezzel kialakult a következő évtizedeket meghatározó két domináns mobilplatform. <span id="operációs-rendszerek"></span> === Operációs rendszerek === A 2000-es években a főbb asztali operációs rendszerek között továbbra is a Microsoft Windows dominált. 2001-ben jelent meg a Windows XP, amely egységes, megbízható NT-alapú rendszermagot hozott a fogyasztói piacra, és az évtized egyik legnépszerűbb operációs rendszerévé vált. A Windows Vista (2007) az elődjét öt évvel követően került kiadásra, jelentős felhasználói felület-változásokkal, de vegyes fogadtatással. Ezt a Windows 7 követte 2009-ben, amely a Vista hiányosságait orvosolta, és stabil, kedvelt rendszerré vált. Az Apple eközben 2001-ben kiadta a Mac OS X-et (10.0), egy Unix-alapokra épített operációs rendszert, amely leváltotta a korábbi “klasszikus” Mac OS-t. A macOS (OS X) új funkciókat és stabilitást hozott a Macintosh gépekre; az évtized során olyan verziók jelentek meg, mint a Tiger (10.4, 2005) és a Leopard (10.5, 2007), majd 2009-ben a Snow Leopard (10.6) további optimalizációkkal. A nyílt forráskódú operációs rendszerek is erősödtek: a Linux kernel 2.6-os főverziója 2003-ban jelent meg, számos fejlesztéssel, és 2004-ben elérhetővé vált az első Ubuntu Linux disztribúció, mely barátságos felhasználói élményével új közönséget vonzott. A Linux a szerverek és különféle beágyazott rendszerek terén egyre nagyobb teret nyert, bár desktop környezetben részesedése korlátozott maradt. A mobil operációs rendszerek ekkoriban születtek meg. A Symbian OS vált az első okostelefonok de facto platformjává (ezt futotta például az Ericsson R380, az első „okostelefon” 2000-ben), és számos Nokia telefonon is ez működött. 2007-ben az Apple az iPhone-nal együtt bemutatta az iPhone OS-t (későbbi nevén iOS), amely érintőképernyős, alkalmazásközpontú mobil operációs rendszerként forradalmasította a telefonok képességeit. 2008-ban a Google kiadta az Android rendszer első verzióját, valamint megjelent az első Android-alapú okostelefon is (HTC Dream). Ezek az új mobil operációs rendszerek lefektették a modern okostelefon-ökoszisztémák alapjait, és a következő években uralkodó platformokká váltak a mobil piacon. <span id="alkalmazások-és-internetes-szolgáltatások"></span> === Alkalmazások és internetes szolgáltatások === Az internet terjedésével a 2000-es években új alkalmazások és online szolgáltatások váltak széles körben elérhetővé. 2001-ben indult útjára a Wikipedia, egy közösségi szerkesztésű online enciklopédia, amely alapjaiban változtatta meg az ismeretterjesztést. Ugyanebben az évben jelent meg az Apple iTunes szoftvere is, amely az online zenevásárlás és -lejátszás úttörője volt, megágyazva a digitális zenei disztribúció robbanásszerű növekedésének. Az elektronikus levelezésben a Google 2004-ben indította el a Gmail szolgáltatást, mely 1 GB-os ingyenes tárhelyével forradalmat hozott az e-mailben. A 2000-es évek közepére elterjedtek az azonnali üzenetküldők és VoIP alkalmazások is (mint a 2003-ban megjelent Skype), amelyek új kommunikációs lehetőségeket nyitottak. A közösségi hálózatok és a felhasználók által létrehozott tartalmak korszaka is ekkor kezdődött. 2003-ban indult a MySpace közösségi portál, amely hamar népszerűvé vált a fiatalok körében, de a 2004-ben alapított Facebook dinamikus terjeszkedésével átvette a vezető szerepet, 2009-re az Egyesült Államokban már megelőzte a MySpace-t a felhasználók számában. 2005-ben elindult a YouTube videómegosztó oldal, lehetővé téve bárki számára videók globális közreadását; a szolgáltatás sikerét jelzi, hogy a Google már 2006-ban felvásárolta. 2006-ban jelent meg a Twitter, egy új mikroblogging platform, amely 140 karakteres üzenetekben tette lehetővé hírek és információk azonnali megosztását. Ezek az alkalmazások alapjaiban formálták át a közösségi interakciókat és a médiafogyasztást. A webböngészők és internetes keresők területén is verseny bontakozott ki ebben az évtizedben. 2004-ben jelent meg a Mozilla Firefox 1.0, az első sikeres nyílt forráskódú böngésző, mely újraélesztette a böngészők közti versenyt és az Internet Explorer egyeduralmát kezdte megtörni. 2008-ban a Google kiadta a Chrome böngészőt, amely gyorsaságával és egyszerűségével hamar nagy piaci részesedést szerzett, néhány éven belül a világ legelterjedtebb böngészőjévé válva. Közben a keresőszolgáltatások közül a Google (1998-ban indult) a 2000-es években vált dominánssá, háttérbe szorítva vetélytársait, és számos kiegészítő szolgáltatást (térkép, hírek, fordítás stb.) indított. Összességében a 2000-es évek alkalmazásai és online platformjai alapozták meg az információmegosztás, a digitális szórakozás és a közösségi média modern kultúráját. <span id="szoftverfejlesztés-és-nyílt-forráskód"></span> === Szoftverfejlesztés és nyílt forráskód === A 2000-es években a szoftverfejlesztés módszerei és közösségei is jelentősen átalakultak. 2001-ben közzétették az '''Agile Manifestót''', amely az agilis szoftverfejlesztési elveket lefektetve forradalmasította a fejlesztési módszertanokat. Az agilis megközelítés – például a Scrum – egyre inkább felváltotta a hagyományos vízesés-modellt, nem csak az informatikában, hanem más iparágak projektmenedzsmentjében is. Ugyancsak ebben az időszakban erősödött meg a nyílt forráskódú szoftverek mozgalma. Számos szoftver vált hozzáférhetővé nyílt licenc alatt: például a Blender 3D modellező program forráskódját 2002-ben közösségi finanszírozás segítségével publikálták. A nyílt forráskód sikere látható volt a böngészőknél (Firefox), operációs rendszereknél (Linux) és sok egyéb területen. Ugyanakkor megjelentek a jogi viták is: 2003-ban a SCO pert indított az IBM ellen arra hivatkozva, hogy a Linux forráskódja jogvédett UNIX-kódot tartalmaz – ez a per évekig elhúzódott, ráirányítva a figyelmet az open source szoftverek licencelési kérdéseire. A programozási technológiák terén a webalkalmazások és a szolgáltatás-orientált architektúrák térnyerése volt jellemző. Új szkriptnyelvek és keretrendszerek (például a PHP alapú tartalomkezelők, vagy a JavaScript AJAX technikája 2005-től) jelentek meg a dinamikus weboldalak kiszolgálására. A vállalati szoftverfejlesztésben a Java és a 2002-ben megjelent .NET platform (C# nyelvvel) dominánssá vált, míg a dinamikus nyelvek (Python, Ruby stb.) is egyre népszerűbbek lettek bizonyos feladatkörökben. A szoftverek terjedése és az internet összekapcsoltsága új biztonsági kihívásokat is hozott: a 2000-ben felbukkanó “ILOVEYOU” számítógépes féreg és a későbbi vírusjárványok milliószám fertőzték a PC-ket világszerte, ami előtérbe állította az IT-biztonság és antivírus megoldások fontosságát. Összességében a 2000-es évek megalapozták a modern szoftverfejlesztési ökoszisztémát, amelyben az agilis módszerek, a nyílt forráskód és az internetközpontú alkalmazások kulcsszerepet kapnak. <span id="közösségi-hatás"></span> === Közösségi hatás === A számítástechnika a 2000-es években a gazdaságra és a mindennapi életre is egyre nagyobb hatást gyakorolt. Az évtized elején lezajlott a sokak által rettegett Y2K („millennium bug”) probléma – a globális erőfeszítéseknek köszönhetően komolyabb üzemzavarok nélkül. Ugyanakkor 2000-ben kipukkadt a dotkom lufi, ami számos technológiai cég csődjét okozta és átmeneti megtorpanást jelentett az internetgazdaságban. A visszaesést azonban gyors növekedés követte: az évtized közepére az online iparágak megerősödtek, és új tech-óriások emelkedtek fel. A Google például a 2000-es években vált a világ vezető keresőjévé és online hirdetési vállalatává; az Amazon és az eBay forgalma az e-kereskedelem robbanásával sokszorosára nőtt. Az Apple a 2000-es években tért vissza a csúcsra az iPod (2001) és az iPhone (2007) sikere révén. 2008-ban a globális gazdasági válság ugyan minden ágazatot érintett, de az informatikai szektor a visszaesést viszonylag jól átvészelte, és az évtized végére a technológia ismét a gazdasági innováció motorjává vált. A társadalomban is mélyreható változásokat indított el a technológia terjedése. Az internetpenetráció ugrásszerűen nőtt ebben az időszakban: 2000-ben a világ népességének alig néhány százaléka rendelkezett internet-hozzáféréssel, 2010-re ez az arány megközelítette a 30%-ot. A mindennapi kommunikáció átalakult: az e-mail, az SMS és az online chat a levelezés és telefonálás mellé zárkózott fel, a közösségi hálózatok (mint a MySpace és Facebook) pedig új fórumot adtak az ismerősökkel való kapcsolattartásra. A médiafogyasztás is változott – egyre többen olvastak híreket online, néztek videókat a YouTube-on, vagy hallgattak zenét digitális formában. Az „információs társadalom” fogalma ekkor vált kézzelfoghatóvá: soha korábban nem volt ennyi ember számára ennyire hozzáférhető a tudás és az információ. Ugyanakkor megjelentek az új kihívások is, például a digitális függőség első jelei, valamint a '''digitális szakadék''' a társadalom különböző rétegei és a világ régiói között – a gyors technológiai fejlődés nyertesei elsősorban a fejlett országok lettek, míg sok fejlődő térség lemaradása nőtt. Összességében a 2000-es évekre a számítástechnika olyan nélkülözhetetlen infrastruktúrává vált, mint az elektromosság: az élet szinte minden területére behatolt, megalapozva a 21. század digitális korszakát. <span id="es-évek-1"></span> == 2010-es évek == <span id="mesterséges-intelligencia-1"></span> === Mesterséges intelligencia === A 2010-es években a mesterséges intelligencia terén korábban csak kutatási szinten létező technikák áttörtek a gyakorlati alkalmazásokba. 2011-ben az IBM '''Watson''' nevű rendszere megnyerte az amerikai Jeopardy! televíziós kvízjátékot, demonstrálva a gépi természetesnyelv-feldolgozás képességeit. 2012-ben a mély neurális hálózatok először értek el kiemelkedő eredményeket látásfelismerési feladatokban (pl. a ImageNet versenyben), ami elindította a “deep learning” forradalmat. Az évtized közepére az MI látványos eredményeket produkált a játékokban: 2016-ban a Google DeepMind által fejlesztett AlphaGo program legyőzte a világ egyik legjobb gojátékosát, Lee Sedolt, amely mérföldkőnek számított a gépi tanulásban. A mesterséges intelligenciát egyre több területen kezdték alkalmazni: az okostelefonokban megjelentek a személyi asszisztensek (Apple Siri, 2011; Amazon Alexa, 2014; Google Assistant, 2016), a gépi fordítás és beszédfelismerés minősége ugrásszerűen javult, és az önvezető autók fejlesztése is felgyorsult. A 2010-es évek végére az MI olyan képességeket mutatott (például képek automatikus felismerése, emberi szintű beszélgetés bizonyos területeken), amelyek előrevetítették a technológia még szélesebb körű alkalmazását a következő évtizedben. <span id="hardver-1"></span> === Hardver === A 2010-es években a számítástechnikai eszközök minden korábbinál elterjedtebbé és sokoldalúbbá váltak. Az okostelefonok uralkodó platformmá nőtték ki magukat: az évtized elején az Apple iPhone és a Google Android alapú készülékek generációi gyors ütemben fejlődtek (nagyobb, nagyfelbontású érintőképernyők, erős többmagos mobilprocesszorok, egyre jobb kamerák). 2010-ben az Apple bemutatta az iPad táblagépet, új kategóriát teremtve a hordozható eszközök piacán. A PC-k hardverében is folytatódott a fejlődés: a processzorok magonkénti teljesítménye lassabb ütemben nőtt, de a magok száma tovább emelkedett, és megjelentek a sokmagos (8+ mag) CPU-k is a fogyasztói piacon (pl. 2017-től az AMD Ryzen széria). A grafikus processzorok (GPU-k) kulcsszerepet kaptak a párhuzamos számítási feladatokban, különösen a mesterséges intelligencia számításokban – az NVIDIA és az AMD egyre nagyobb és hatékonyabb GPU-kat dobott piacra. A félvezetőgyártás a 2010-es évek végére a 10 nm alatti csíkszélességet is elérte, bár a fizikai korlátok miatt a Moore-törvény üteme lassult. Az évtized során számos új hardvertechnológia jelent meg. 2014-ben bemutatkozott a nyílt forrású '''RISC-V''' utasításkészlet-architektúra, amely lehetővé tette testreszabható processzorok fejlesztését. A memória és háttértár kapacitások nagyságrendekkel nőttek: 2010-re általánossá váltak a gigabájtos memóriák és több száz gigabájtos – később terabájtos – merevlemezek, valamint a félvezető alapú SSD-k is egyre inkább felváltották a hagyományos winchestereket (2016-ra megjelentek az első 10+ terabájtos meghajtók). A szuperszámítógépek terén Kína és az Egyesült Államok versengett az első helyért: 2011-ben átlépték a 10 petaflops határt, 2018-ra pedig már 200 petaflops feletti gépek vezették a ranglistát. 2019-ben a Google bejelentette, hogy kvantumszámítógépe elérte a „kvantumfölényt” egy specifikus feladatban, jelezve a kvantumszámítások terén elért előrelépést. Ezen innovációk révén a 2010-es évek végére a hardver lehetővé tette korábban elképzelhetetlen komplexitású számítások elvégzését, az eszközök pedig mindennapjaink részévé váltak (okosórák, fitnesz-trackerek, okoshangszórók formájában is). <span id="operációs-rendszerek-1"></span> === Operációs rendszerek === A 2010-es években az operációs rendszerek terén a Microsoft, az Apple és a mobilplatformok fejlődése volt meghatározó. A Microsoft 2012-ben jelentette meg a radikálisan új felületű Windows 8-at, amely az érintőképernyős eszközökhöz igazodott, ám vegyes fogadtatásban részesült. 2015-ben kijött a Windows 10, amely visszahozott sok hagyományos elemet és egységes platformot kínált PC-kre és tabletekre egyaránt – a Microsoft ezt “szolgáltatásként” fejlesztette tovább folyamatos frissítésekkel. Az Apple macOS rendszere évente frissült: olyan verziók jelentek meg, mint a macOS Sierra, High Sierra, majd 2019-ben a macOS Catalina, amelyek fokozatos fejlesztésekkel bővítették az Apple ökoszisztémát. Külön fontos lépés volt, hogy az Apple 2011-ben bemutatta az iCloud szolgáltatást, integrálva az eszközök közti adat-szinkronizációt az OS-be. Mobil fronton a Google Android és az Apple iOS dominanciája egyértelművé vált. Az Android számos verzión keresztül (Gingerbread-től a Pie-ig) fejlődött a 2010-es években, és nyílt forráskódú jellege miatt a világ legelterjedtebb operációs rendszerévé vált okostelefonokon. Az iOS közben megtartotta erős pozícióját a prémium szegmensben, évente megújuló verziókkal (pl. iOS 7 teljes dizájnváltása 2013-ban). A korábbi mobil OS-ek – mint a BlackBerry OS és a Windows Phone (2010-ben indult) – nem tudták tartani a lépést, a BlackBerry 2016-ra átállt Androidra, a Windows Phone pedig 2017-ben gyakorlatilag megszűnt. Az új eszközkategóriák (okosórák, okostévék, autós fedélzeti rendszerek) saját specializált operációs rendszerekkel jelentek meg (pl. Android Wear, Apple watchOS, Samsung Tizen), tovább szélesítve az OS-ek családját. Emellett a nyílt forrású Linux továbbra is kulcsszerepet játszott a szervereken és felhőszolgáltatásokban, a containerizáció (Docker) és az orchestration (Kubernetes) pedig újfajta “operációs rendszer-szintű” réteget adtak a felhő infrastruktúrához. <span id="alkalmazások-és-szolgáltatások"></span> === Alkalmazások és szolgáltatások === A 2010-es években az internetes alkalmazások és digitális szolgáltatások minden területen előretörtek. A közösségi média globálisan uralkodó kommunikációs platformmá vált: a Facebook felhasználóinak száma 2012-re átlépte az egymilliárdot, majd az évtized végére a 2 milliárdot is meghaladta, részben az olyan felvásárlások révén, mint az Instagram (2012) és a WhatsApp (2014). A Twitter a hírek és közéleti diskurzus fontos csatornájává vált világszerte. Új szereplők is megjelentek: 2011-ben indult a Snapchat, amely az eltűnő üzenetekkel új trendet teremtett, a fiatalabb generációk körében pedig a TikTok (2016-tól nemzetközileg) rövid videós platformja robbant be az évtized végén. A fejlődő világban – különösen Kínában – saját ökoszisztémák nőttek fel: a WeChat például egyetlen alkalmazásban egyesítette az üzenetküldést, közösségi médiát és fizetési szolgáltatásokat. Az online médiafogyasztás is alapjaiban változott meg. A videó-streaming lett a szórakoztatás egyik fő formája: a Netflix átalakult DVD-kölcsönzőből globális streaming platformmá, saját tartalomgyártással, a YouTube pedig a legnagyobb nyilvános videóplatform maradt, ahol már milliárdos nézettségű videók születtek. A zeneiparban a streaming modellek (Spotify, Apple Music) váltak dominánssá, háttérbe szorítva a letöltést és a fizikai adathordozókat. Az okostelefonos alkalmazásboltok (Apple App Store, Google Play) több millió alkalmazást kínáltak – a mindennapi tevékenységek (ételrendelés, navigáció, bankolás, társkeresés stb.) egyre inkább mobilappokon keresztül zajlottak. Az ún. “megosztáson alapuló gazdaság” is a technológiai platformokra épült: az Uber és társai megreformálták a városi személyszállítást, az Airbnb pedig a szálláskiadást alakította át globálisan. Emellett az online játékok és e-sportok hatalmas iparággá fejlődtek (pl. a League of Legends és a Dota 2 nemzetközi bajnokságai). A 2010-es évek végére a digitális szolgáltatások az élet minden területén jelen voltak, a hagyományos ágazatok (kiskereskedelem, média, közlekedés, pénzügyek) működését is gyökeresen átalakítva. <span id="szoftverfejlesztés-és-infrastruktúra"></span> === Szoftverfejlesztés és infrastruktúra === A szoftveriparban a 2010-es évek kulcsszavai a „felhő” és a „big data” lettek. A vállalatok tömegesen tértek át a felhőalapú infrastruktúrákra – az Amazon Web Services, a Microsoft Azure és a Google Cloud Platform szolgáltatásai lehetővé tették, hogy rugalmasan, igény szerint skálázhatóan futtassák alkalmazásaikat a vállalatok. A fejlesztési és üzemeltetési folyamatok összeolvadtak a DevOps szemléletben, és elterjedtek a konténertechnológiák: a Docker (2013) konténerei és a Kubernetes (2014) orkesztrációs rendszere szabvánnyá váltak a felhős alkalmazások telepítésében. Az adatelemzés és gépi tanulás terén új eszközök jelentek meg: a Hadoop és Spark keretrendszerek lehetővé tették a hatalmas adathalmazok (big data) feldolgozását, míg a TensorFlow (2015) és más gépi tanulási könyvtárak révén a mesterséges intelligencia fejlesztése széles körben elterjedt. A programozási nyelvek között is volt mozgás: az Apple 2014-ben bemutatta a Swift nyelvet a biztonságosabb és modernebb iOS/macOS-fejlesztéshez, a Mozilla által fejlesztett Rust (stabil 2015-től) pedig a memória-biztonságot helyezte előtérbe a rendszerszoftverek terén. A JavaScript nyelv a Node.js platform (2009) és a front-end keretrendszerek révén full-stack fejlesztési eszközzé vált. Az évtized során egyre hangsúlyosabb lett az informatikai biztonság. Számos nagy horderejű adatvesztés és kibertámadás történt: 2013-ban derült fény arra, hogy az amerikai NSA tömeges megfigyeléseket végzett az interneten (Edward Snowden kiszivárogtatásai), ami világszerte aggodalmat keltett a magánszféra védelmét illetően. 2017-ben a WannaCry zsarolóvírus világszerte számítógépek százezreit fertőzte meg, rávilágítva a sebezhető, frissítetlen rendszerek veszélyeire. 2018 elején nyilvánosságra kerültek a Meltdown és Spectre nevű hardver-sebezhetőségek, amelyek szinte minden modern processzort érintettek, és sürgős szoftveres javításokat követeltek a rendszerek védelme érdekében. A GDPR európai uniós adatvédelmi rendelet 2018-ban lépett életbe, szigorúbb szabályokat hozva a személyes adatok kezelésére. A szoftverfejlesztés és üzemeltetés világában mindezek hatására alapvető követelménnyé vált a biztonságos kódolás, a gyors frissítési képesség és a folyamatos monitorozás, miközben a fejlesztők soha nem látott eszköztárral dolgozhattak a felhő és az open source révén. <span id="közösségi-hatás-1"></span> === Közösségi hatás === A 2010-es években a digitális technológia hatása a társadalomra még nyilvánvalóbbá vált. A közösségi média nemcsak a személyes kapcsolattartást, hanem a politikát és a társadalmi mozgalmakat is befolyásolta: 2011-ben az '''Arab tavasz''' eseményei során a Facebookot és a Twittert a tüntetések szervezésére használták, míg a későbbi években is számos tiltakozás és kampány (pl. a #MeToo mozgalom 2017-ben) az online platformokon szerveződött. Ugyanakkor egyre nagyobb aggodalmat keltett a dezinformáció terjedése és az „echo chamber” jelenség – különösen a 2016-os amerikai elnökválasztás kapcsán merült fel a vád, hogy a közösségi oldalak elősegítik az álhírek terjedését. 2018-ban a Cambridge Analytica botrány rámutatott, hogy a Facebook felhasználói adatokat politikai célokra is fel lehet használni, ami globális vitát indított a személyes adatok védelméről. A kormányzati megfigyelés is a figyelem középpontjába került: Edward Snowden 2013-as leleplezései nyomán világossá vált, hogy a nemzetbiztonsági szervek kiterjedt elektronikus megfigyelést folytatnak. Mindezek hatására szigorúbb szabályozás született (az EU GDPR rendelete 2018-ban lépett életbe), és nőtt az igény az erősebb titkosítás és a magánszféra védelme iránt. A mindennapi élet és kultúra is átalakult a 2010-es években a technológia által. Az okostelefon folyamatos jelenléte megváltoztatta a munka és a magánélet közötti határvonalat, sokan napi szinten órákat töltöttek a képernyők előtt. Megjelent a '''digitális függőség''' fogalma, valamint a technológia mentális egészségre gyakorolt hatásainak vizsgálata. Ugyanakkor a digitális gazdaság kényelmet és új lehetőségeket hozott: az online vásárlás (e-commerce) az egész világon elterjedt, a streaming és on-demand szolgáltatások testre szabták a médiafogyasztást, az okoseszközök (pl. fitnesszkarkötők) pedig az egészségtudatos életmód részévé váltak. A munka világában megjelent a távmunka és a szabadúszó gig-gazdaság a digitális platformok révén, bár ez felvetette a munkavállalói jogok és a munkahelyi biztonság kérdéseit. A világ internet-használóinak aránya az évtized végére már meghaladta az 50%-ot, de a digitális szakadék tovább élt: a vidéki és szegény térségek lemaradása még mindig kihívást jelentett. Összességében a 2010-es évekre a digitalizáció a társadalom alapvető szövetét is átszőtte – az információ, a kommunikáció és a gazdaság alapvetően online térbe helyeződött át, új előnyöket és új problémákat egyaránt szülve. <span id="as-évek"></span> == 2020-as évek == <span id="mesterséges-intelligencia-2"></span> === Mesterséges intelligencia === A 2020-as évek elején a mesterséges intelligencia ugrásszerű fejlődése a széles nyilvánosság számára is nyilvánvalóvá vált. 2020-ban megjelent az OpenAI '''GPT-3''' nyelvi modellje, amely addig soha nem látott minőségben volt képes összefüggő szövegeket generálni. 2022 végén hatalmas visszhangot váltott ki a ChatGPT nevű chatbot, amely a GPT-3.5 modellen alapult és párbeszédes formában nyújtott az emberihez közeli válaszokat – néhány hónap alatt több mint 100 millió felhasználó próbálta ki világszerte. 2023-ban az OpenAI bemutatta a még fejlettebb GPT-4 modellt, ami tovább fokozta az MI körüli érdeklődést. A generatív MI nemcsak szövegben, hanem a képi területen is áttörést ért el: 2022-ben nyilvánossá váltak olyan programok (DALL-E 2, Stable Diffusion, Midjourney), amelyek szöveges leírás alapján képesek magas minőségű képeket alkotni. Egy ilyen mesterségesen generált kép meg is nyert egy művészeti versenyt 2022-ben, ami vitát indított a digitális művészet jövőjéről. Ugyanebben az évben a DeepMind AlphaFold rendszere előrejelezte gyakorlatilag az összes ismert fehérje térbeli szerkezetét, óriási erőforrást teremtve a biológiában. Az MI alkalmazásai a 2020-as években már mindennapossá váltak: ajánlórendszerek szűrik a közösségi média és streaming tartalmakat, az okostelefonok kamerái MI-algoritmusokkal javítják a fotókat, a fordítóprogramok valós időben működnek, és a navigációs alkalmazások valós idejű forgalmi adatokat használnak fel. Ugyanakkor az MI fejlődése egyre több aggodalmat is felvetett. A társadalomban vita bontakozott ki arról, hogy a mesterséges intelligencia miként hat a munkaerőpiacra (számos rutinfeladat automatizálhatóvá vált), az oktatásra (a chatbotok képesek megírni esszéket a diákok helyett) és az információ hitelességére (MI által generált álhírek és deepfake videók jelenhetnek meg). 2023-ban több szakértő nyílt levélben figyelmeztetett az esetleges túlságosan fejlett MI kockázataira, és szabályozás kidolgozását sürgette. Mindezek alapján a 2020-as évekre a mesterséges intelligencia fejlődése egyszerre kínált páratlan lehetőségeket és új kihívásokat, amelyek megoldása a következő évek feladata lesz. <span id="hardver-2"></span> === Hardver === A 2020-as évek elején a számítástechnikai hardvert elsősorban a globális események és a specializált igények formálták. A 2020-ban kitört COVID-19 világjárvány egyszerre növelte a digitális eszközök iránti keresletet és akadozást okozott az ellátási láncokban, ami súlyos félvezető-hiányhoz vezetett 2021-ben – ez rávilágított a modern gazdaság függésére a chipgyártástól. Időközben a személyi számítógépek piacán fontos váltás történt: az Apple 2020-ban piacra dobta első saját tervezésű, ARM-alapú számítógépes chipjét (Apple M1), amely kiemelkedő teljesítményt nyújtott alacsony fogyasztás mellett, jelezve az ARM architektúra életképességét a PC-ken is. A PC-processzorok terén az AMD és az Intel versenye folytatódott; az Intel 2021-ben mutatta be a hibrid magstruktúrájú Alder Lake architektúrát, míg az AMD a Zen 3 és Zen 4 processzorokkal erősítette pozícióját. A grafikus kártyák piacát nagyban befolyásolta a kriptovaluta-bányászat fellendülése, majd visszaesése: 2020-21-ben az NVIDIA és AMD GPU-k hiánycikké váltak a bányászok kereslete miatt, 2022-re azonban a kriptopiac összeomlása után normalizálódott a kínálat. A telekommunikációban a 2020-as évek elején széles körben bevezették az 5G mobilhálózatokat, lehetővé téve a gigabites sebességű vezeték nélküli adatátvitelt és új alkalmazásokat (IoT, önvezető autók kommunikációja). Az IoT-eszközök száma exponenciálisan nőtt: okosotthon-eszközök, szenzorhálózatok, ipari IoT rendszerek terjedtek el, amelyek rengeteg adatot gyűjtenek valós időben. A szuperszámítógépek versenyében mérföldkőhöz érkeztünk: 2022-ben az amerikai Frontier rendszer lett az első, amely átlépte az exaflops (10^18 művelet/másodperc) teljesítményt, ezzel új korszakot nyitva a nagy teljesítményű számításban. A kvantumszámítógépek is tovább fejlődtek: a qubit-ek száma egyre nő a kísérleti rendszerekben (2021-ben az IBM egy 127 qubit-es processzort jelentett be), bár a kvantumeszközök gyakorlati alkalmazása még korlátozott. Az évtized elején megjelentek az első önvezető taxik kísérleti jelleggel egyes városokban, illetve a magánűrhajózás fellendülése (SpaceX, Blue Origin) is kihasználta a fejlett számítógépes rendszereket. Összességében a hardver terén a 2020-as években a teljesítmény növelése mellett a megbízhatóság és az ellátási stabilitás kérdései is előtérbe kerültek, miközben egyre több speciális célhardver (MI-gyorsítók, kvantumchipek) jelent meg a hagyományos CPU/GPU páros kiegészítéseként. <span id="operációs-rendszerek-2"></span> === Operációs rendszerek === A 2020-as évek elején az operációs rendszerek terén a változások inkább evolúciósak, semmint forradalmiak voltak. A Microsoft 2021-ben adta ki a Windows 11-et, amely modernizált felhasználói felületet hozott és magasabb hardverkövetelményeket támasztott (például csak biztonsági chipet tartalmazó PC-ken támogatott) – ezzel a cég gyakorlatilag lezárta a Windows 10 „örök Windows” korszakát. Az Apple folytatta éves macOS frissítési ciklusát, immár natív támogatással az új ARM alapú Apple Silicon chipekre; a macOS Big Sur (2020) és utódai már optimalizáltan futottak az M1/M2 chipeken. A desktop Linux továbbra is egy stabil, de kisebbségi szereplő maradt az asztali gépeken, viszont a felhőben és szervereken domináns pozícióban volt. A mobil operációs rendszerek – Android és iOS – uralma megkérdőjelezhetetlen maradt. Az Android 2020-as években kiadott verziói (11, 12, 13) tovább finomították a rendszer teljesítményét és biztonságát, míg az iOS is évente frissült új funkciókkal (pl. widgetek, értesítési reform). A Huawei amerikai szankciók miatti kiszorulása nyomán a cég 2021-ben saját HarmonyOS rendszerét kezdte el fejleszteni, de ez elsősorban Kínában terjedt. Az okoseszközök (óra, TV, autó) világában az Android és Linux alapú beágyazott rendszerek domináltak. Az operációs rendszerek frontján tehát a 2020-as évek a konvergencia jegyében teltek: minden platform igyekezett hasonló felhasználói élményt nyújtani, széles ökoszisztémákkal (alkalmazásboltok, felhő-szolgáltatások) kiegészítve. A virtualizáció és a konténerezés továbbra is kulcsfontosságú volt a szerveroldalon, de a végfelhasználó ezt már nagyrészt láthatatlan felhős háttérszolgáltatásként érzékelte. <span id="alkalmazások-és-szolgáltatások-1"></span> === Alkalmazások és szolgáltatások === A 2020-as évek elejét alapvetően meghatározta a COVID-19 járvány, ami felgyorsította számos digitális szolgáltatás térnyerését. 2020-ban és 2021-ben emberek százmilliói kényszerültek otthoni munkavégzésre és tanulásra, ami az olyan videokonferencia-platformok sikeréhez vezetett, mint a Zoom, a Microsoft Teams vagy a Google Meet. A távmunka és hibrid munkavégzés a pandémia lecsengése után is sok helyen megmaradt, így ezek az alkalmazások hosszú távon is beépültek a vállalati működésbe. Az online kereskedelem szintén rekord növekedést ért el a lezárások alatt, az élelmiszer-házhozszállító és e-kereskedelmi szolgáltatások (pl. Instacart, Amazon) kritikus infrastruktúraként működtek. A közösségi média ökoszisztémája is változott: a TikTok 2020-ra a világ legletöltöttebb alkalmazásává vált, és meghonosította a rövid, pörgős videók trendjét, amelyre a konkurensek (Instagram Reels, YouTube Shorts) is reagáltak. A Facebook (Meta) 2021-ben nagy lendülettel hirdette meg a “metaverzum” vízióját – át is nevezte magát Meta Platforms-nak –, és erőforrásokat fektetett a virtuális valóság alapú közösségi terek fejlesztésébe, de a metaverzum koncepció egyelőre nem váltotta be a hozzá fűzött reményeket. Eközben a digitális szórakoztatás más formái virágoztak: a videojáték-ipar bevétele meghaladta a filmiparét, az e-sport események és streamingek (pl. Twitch) hatalmas közönséget vonzottak. A hagyományos mozik és tévézés népszerűsége csökkent, miközben a streaming-szolgáltatók (Netflix, Disney+, HBO Max stb.) egymással versengve gyártották az exkluzív tartalmakat a nézők megtartásáért. Az évtized elején lezajlott egy kriptovaluta- és blokklánc-őrület is. 2021-ben a Bitcoin árfolyama soha nem látott magasságba emelkedett, és sorra jelentek meg a decentralizált pénzügyi (DeFi) alkalmazások, valamint a NFT-k (nem helyettesíthető tokenek) a digitális műtárgypiacon. 2022-re azonban a kriptovaluta-piac összeomlott: több nagy szolgáltató (pl. FTX tőzsde) csődbe ment, a tokenek értéke zuhant, és sok befektető veszteségeket szenvedett el. Mindez valamelyest hűtötte a “Web3” néven emlegetett, blokklánc-alapú internet vízióját. Ugyanakkor a digitális fizetési megoldások (mobilfizetés, fintech alkalmazások) mainstreammé váltak: a járvány is hozzájárult a készpénzmentes tranzakciók terjedéséhez. Összességében a 2020-as évek első fele az alkalmazások terén a virtuális kapcsolattartás, a streaming és a digitális gazdaság további térnyerését hozta, miközben új hype-ok születtek és buktak el a tech világ gyors ciklusában. <span id="szoftverfejlesztés-és-infrastruktúra-1"></span> === Szoftverfejlesztés és infrastruktúra === A 2020-as évek elején a szoftveres infrastruktúra további felhősödése és automatizálása zajlott. A nagy felhőszolgáltatók (AWS, Azure, Google Cloud) piaci részesedése tovább nőtt, bár egyre több szervezet törekedett multi-cloud vagy hibrid megoldásokra az elosztott kockázat érdekében. Az alkalmazások üzemeltetésében az ún. „felhő-natív” megközelítés vált általánossá: konténerekben és mikroszolgáltatásokban gondolkodtak a fejlesztők, és az infrastruktúra-szolgáltatások (Infrastructure as Code) automatizáltan, kóddal vezérelve működtek. A 2020-as évek elején a fejlesztői eszköztárba belépett a mesterséges intelligencia is: 2021-ben elindult a GitHub Copilot, amely képes kódrészleteket javasolni a fejlesztőknek a mesterséges intelligencia segítségével, 2022–2023-ban pedig a ChatGPT-hez hasonló modelleket már komplex programkód generálására is használták. Ez felgyorsíthatja a fejlesztést, de felveti a kérdést a kódminőség és a szerzői jog kapcsán is, hiszen az MI sok esetben nyílt forráskódú projektek kódján tanult. A szoftverbiztonság továbbra is kritikus kérdés maradt. 2020-ban egy nagyszabású supply chain-támadás derült ki (a SolarWinds nevű vállalat szoftverfrissítését feltörve kormányzati rendszerekbe jutottak be hekkerek), 2021-ben pedig a Log4Shell sebezhetőség rengeteg szervert érintett világszerte, bizonyítva hogy egy apró nyílt forrású komponens hibája is globális krízist okozhat. Mindez felgyorsította az ellátási lánc biztonságának vizsgálatát és az úgynevezett nulladik napi (zero-trust) biztonsági modellek terjedését. A nemzetek kormányai is egyre jobban figyeltek a szoftveriparra: az USA 2022-ben elfogadta a CHIPS és Science Act-et a félvezetőgyártás támogatására, az EU pedig kidolgozta az AI Act tervezetét a mesterséges intelligencia szabályozására. A szoftverfejlesztés kultúráját eközben a „távolról együttműködés” jellemezte: a fejlesztőcsapatok sokszor földrajzilag szétszórtan, online eszközökkel együttműködve dolgoztak. A 2022–2023-ban bekövetkező nagyszabású tech-leépítések (több nagyvállalat egyszerre több ezer mérnököt bocsátott el) rámutattak, hogy a szektor sem immunis a gazdasági ciklusokra. Összességében a szoftveripar a 2020-as években is a rugalmasságot, automatizációt és biztonságot helyezte előtérbe az egyre összetettebb rendszerek kiszolgálása érdekében. <span id="közösségi-hatás-2"></span> === Közösségi hatás === A 2020-as évek elejét a COVID-19 pandémia határozta meg, amely példátlan módon tette próbára a világ társadalmait – és a technológia kulcsszerepet játszott a válaszadásban. Az emberek tömegesen szorultak a digitális térbe: a munkahelyi meetingektől az iskolai oktatásig, sőt a baráti találkozókig sok minden átkerült az online platformokra. Ez felgyorsította a digitalizációt olyan területeken is, ahol korábban lassabb volt (pl. telemedicina, e-kormányzat). Ugyanakkor rámutatott a társadalmi egyenlőtlenségekre is: akinek nem volt stabil internetkapcsolata vagy digitális eszköze, az lemaradt – a digitális szakadék problémája így új megvilágításba került. A pandémia alatt az álhírek és összeesküvés-elméletek is virálisan terjedtek az interneten (pl. vakcina-ellenes mozgalmak), ami tovább fokozta a hiteles tájékoztatás kihívását. A geopolitikában is megjelent a technológiai vetélkedés. Az USA és Kína között technológiai hidegháború bontakozott ki: az Egyesült Államok korlátozásokat vezetett be a kínai cégek (pl. Huawei, TikTok) ellen adatbiztonsági és nemzetbiztonsági aggályokra hivatkozva, valamint exporttilalmat rendelt el a csúcstechnológiájú chipekre és berendezésekre (2022). Kína ezzel párhuzamosan igyekezett saját önellátását erősíteni a félvezetők és szoftverek terén. 2022-ben kitört az orosz–ukrán háború, ahol a kibertámadások, a műholdas internetszolgáltatások (SpaceX Starlink) és a közösségi média narratívaháborúja mind a konfliktus részévé váltak. A technológiai nagyvállalatok erejét továbbra is vitatták: az EU-ban életbe lépett a Digitális Szolgáltatások és Digitális Piacok törvénye (DSA, DMA), hogy szabályozza a „Big Tech” hatalmát, és világszerte vizsgálták a Google, Amazon, Facebook monopóliumait. Mindeközben a mindennapokban az emberek életét egyre inkább átszőtte a technológia. A távmunkának és rugalmasságnak köszönhetően felértékelődött az életminőség és a vidékre költözés lehetősége, bár ez nem mindenhol valósult meg. Az okoseszközök és alkalmazások rengeteg adatot gyűjtöttek a felhasználókról, ami egyrészt személyre szabott élményeket nyújtott, másrészt folyamatos megfigyelés érzését kelthette. A mesterséges intelligencia 2023-as robbanása ismét aggodalmat keltett: sokan tartanak attól, hogy a generatív MI elmosta a valós és hamis tartalmak határát, illetve bizonyos szakmák (pl. ügyfélszolgálat, tartalomgyártás) munkahelyeit fenyegetheti. Ugyanakkor az innováció reményekre is okot ad: az MI-től orvosi áttöréseket, az automatizálástól pedig veszélyes vagy monoton munkák kiváltását várják. A 2020-as évek elejére a társadalom nagy kérdése az lett, hogyan lehet a technológia előnyeit maximalizálni úgy, hogy közben kontroll alatt tartjuk a káros hatásokat – legyen szó az egyéni mentális egészségről, a demokrácia védelméről vagy a nemzetbiztonságról. {{-ford-}} {{trans-top}} *{{en}}: {{t+|en|history of computing}} {{trans-bottom}} {{hunl}} {{Timeline History of Computing}} h5vwhinf5w444wyqb2xn7baumy9xbcy 0 809109 3523817 3510887 2026-07-10T19:53:22Z Neriassel 28746 3523817 wikitext text/x-wiki {{azonnali|nem szótárcikk, ez wikipédiára való|[[Szerkesztő:Neriassel|Neriassel]] ([[Szerkesztővita:Neriassel|vita]]) 2026. július 10., 21:53 (CEST)}} {{TopicTOC-Chemistry}} {{engfn}} # {{label|en|informatika}} <span id="a-kémia-története"></span> = A kémia története = <span id="az-ókori-kémiai-ismeretek-és-gyakorlatok-mezopotámia-egyiptom-india-kína-görög-és-római-világ"></span> == Az ókori kémiai ismeretek és gyakorlatok (Mezopotámia, Egyiptom, India, Kína, görög és római világ) == Az emberiség kémiai ismeretei az őskorba nyúlnak vissza. Már a korai ember használta a tüzet a főzéshez és fémek hevítéséhez, és készített egyszerű eszközöket kőből vagy csontból. A fazekasság (agyagedények kiégetése) is ősi technológia, amely kémiai változást – az agyag keményedését – foglal magában. Ezek a gyakorlati ismeretek jelentették a kémia kezdeti lépéseit. '''Ókori Mezopotámiában és Egyiptomban''' Kr. e. 4000 körül már jelentős gyakorlati kémiai tudás halmozódott fel. Számos anyag-előállítási és feldolgozási eljárást ismertek: többek között tudtak agyagedényeket kiégetni, bitumenből nyers aszfaltot és gipszből vakolatot készíteni, mázazást és üvegkészítést végezni, sörfőzést folytatni, bőröket cserzeni, ecetet előállítani, kozmetikumokat és balzsamozó olajokat készíteni, szappant főzni, textíliákat színezőnövények és állati festőanyagok segítségével színezni, valamint élelmiszereket tartósítani. Egyiptomban például kifejlett söripar működött: a sört erjesztett kenyérből, datolya és méz hozzáadásával állították elő. Az ókoriak már szappant is készítettek fa hamujának lúgtartalmát olajjal/állati zsiradékkal felfőzve. A textíliák festésére különféle természetes forrásokat használtak: indigót a festőcsülleng leveleiből, vörös festéket a rubia (buzér) gyökeréből, sárgát a sáfrány virágából, sőt egyes rovarokból (bíbortetű) is nyertek karmazsin festéket. Kiemelkedő festőanyag volt a bíborfesték (türoszi bíbor), amelyet tengeri csigák (Murex fajok) mirigyváladékából nyertek ki. Ehhez mintegy 10 000 csigát kellett három napig sós lében főzni, mire alig néhány gramm igen tartós és intenzív bíborszínű festéket kaptak – ezt a festéket már ~4000 éve, a föníciai Türosz városában is előállították, innen ered a neve. Az ókori egyiptomiak számos szervetlen anyagot is ismertek és felhasználtak, például a timsót (aluminium-szulfát), ként, konyhasót, ólom-szulfátot, ólom-oxidot (minium), réz-acetátot, antimon-szulfidot vagy cink-oxidot. Több ezek közül élénk színű pigment volt: a sárga-narancs okker (vas-oxid agyagban), a zöld malachitpor (bázisos réz-karbonát), a fekete korom (finom szemcséjű szén), a fehér kréta (kalcium-karbonát) vagy gipsz. Figyelemre méltó az '''egyiptomi kék''' nevű mesterséges pigment, amelyet az egyiptomiak fejlesztettek ki. Ezt a ragyogó kék színanyagot mész, réztartalmú ásvány (malachit) és finom homok keverékének erős hevítésével állították elő; az eredmény egy kalcium-réz-szilikát összetételű anyag lett (CaO·CuO·4SiO₂), amely az első ismert szintetikus pigment volt. [[File:Egyptian blue Altes Museum.JPG|thumb| ''Egy egyiptomi kék pigmenttel színezett ókori edény (pyxis) az i. e. 8. századból. Az „egyiptomi kék” a történelem első mesterségesen előállított pigmentje volt, amelyet mész, homok és rézérc keverékének magas hőfokon való kiégetésével hoztak létre.'']] A bányászat és fémkohászat is jelentős fejlődést ért el az ókorban. Már ismerték és hasznosították az aranyat, ezüstöt, rezet és ólmot. Az arany és ezüst gyakran elemi állapotban fordult elő, míg a rezet és ólmot ércből (oxidjaikból vagy karbonátjaikból) faszénnel redukálva olvasztották ki kemencékben. Kr. e. 3500 körül kezdődött a '''bronzkor''', amikor felfedezték, hogy a réz és ón megfelelő arányú ötvözésével keményebb fémet (bronzot) kapnak. Az egyiptomiak Kr. e. 1500-ra már magas szinten művelték az arany- és ezüstművességet, az ötvösök kitűnő arany- és ezüsttárgyakat hoztak létre. A vasat azonban eleinte még nem tudták ilyen módon előállítani, így a kevés ismert vas meteoritleletekből származott: az egyiptomiak az égből hullott meteoritvasat használták fel (ezt hívták „'''vasnak az égből'''”), és emiatt úgy gondolták, maga az ég is vasból lehet. Mezopotámia térségében (a mai Irak területén) szintén folytattak kohászati és egyéb kémiai jellegű tevékenységeket. Egy sumér agyagtábla tanúsága szerint már Kr. e. 2500 körül készítettek szappanszerű anyagot fahamu lúgjának és olajnak a felfőzésével. Mezopotámiából indulhattak ki olyan praktikus eljárások is, amelyeket aztán az egyiptomiak továbbfejlesztettek és tökéletesítettek. Az ókori '''India''' kémiai és filozófiai elképzelései szintén figyelemre méltóak. Az indiai természetfilozófiában már Kr. e. 600 körül megjelent az öt őselem tana – a klasszikus föld, víz, tűz, levegő mellett az üres tér (akasa) és a fény is alapelemnek számított bizonyos iskolákban –, míg például a buddhizmus hat elemet tartott számon (a hagyományos négy elem mellett a tér és a tudat is elem). Egy Kanada nevű filozófus Kr. e. ~500-ban megfogalmazta az atomok létezésének gondolatát: eszerint az atomok oszthatatlan, örök részecskék, amelyek mérete rendkívül kicsi (egy napsugárban táncoló porszem hatodrésze), továbbá az atomok kettő, három vagy négy összekapcsolódásával molekulák keletkezhetnek. A Vaisésika filozófiai iskola szerint az atomoknak különféle tulajdonságai lehetnek (például szín, íz, illat). E korai indiai atomelmélet meglepő hasonlóságot mutat az ókori görögök atomisztikus nézeteivel – a tudománytörténészek máig vitatják, hogy e hasonlóság a kulturális kölcsönhatásnak vagy a független párhuzamos fejlődésnek tudható be. Az indiaiak gyakorlati téren is jeleskedtek: magas színvonalon űzték a fémművességet és a technikai kémiát. Kiváló minőségű acélt (úgynevezett wootz-acélt) állítottak elő már az ókorban, és számos fémmegmunkálási eljárást alkalmaztak. Az ősi Indiában a vegyészet (alkímia) is virágzott, különösen a higany alapú elixírek és gyógyitalok terén értek el eredményeket. Az ókori '''Kína''' ugyancsak gazdag kémiai hagyományokkal bírt. A kínai filozófia az anyagi világot öt alapelemre vezette vissza (fa, fém, víz, tűz, föld), és a kínai alkímia két fő célja az '''életelixír''' (a halhatatlanság itala) elkészítése, valamint a fémek arannyá '''transzmutálása''' volt. A kínai mesterek a gyakorlati technológiákban is élen jártak: már a Kr. e. 4–3. században, a Hadakozó Fejedelemségek idején magas hőmérsékletű fújtatós kemencéket alkalmaztak, és elsőként állítottak elő nagy mennyiségben öntöttvasat ércekből. A kínai kohászok találták fel a krómbevonat alkalmazását is a fémek rozsda elleni védelmére: a Csin Si Huang császár (Kr. e. 3. sz.) sírjában talált bronz nyílhegyeket vékony króm-oxid réteggel vonták be, így azok több mint 2000 év után is fényesen, rozsdamentesen kerültek elő. A kínai alkimisták kísérletei vezettek egy világraszóló találmányhoz is a középkor hajnalán: a 9. században – valószínűleg az örök élet elixírjének keresése közben – felfedezték a puskaport, az első robbanóképes kémiai elegyet, ami forradalmasította a hadviselést. '''Az ókori görögök és rómaiak''' elsősorban elméleti síkon járultak hozzá a kémia fejlődéséhez. A görög filozófusok megpróbálták racionálisan megmagyarázni, miért különböznek az anyagok (például színükben, sűrűségükben, viselkedésükben). Ennek során megszülettek az első természettudományos igényű elméletek az anyagok felépítéséről. '''Empedoklész''' (~Kr. e. 450) szerint minden anyag négy őselem kombinációjából áll: földből, vízből, levegőből és tűzből. '''Démokritosz''' (~Kr. e. 370) ezzel szemben azt tanította, hogy az anyag parányi, tovább nem osztható részecskékből – atomokból – épül fel. Híres mondása szerint az „atom” (atomosz) szó jelentése: oszthatatlan. A két felfogás hívei között vita bontakozott ki: '''Arisztotelész''' (Kr. e. 4. sz.) tagadta az atomok létét, mert úgy vélte, az anyag folyamatos (nem részecskékből álló) közeg, amely kitölti a teret, így nem létezhet üres tér (vákuum). Arisztotelész ehelyett az empedoklészi négy őselemet fejlesztette tovább, bevezetve a négy elemhez társuló négy minőséget: a meleget, hideget, nedvességet és szárazságot. Úgy vélte, minden anyag e négy elem és négy tulajdonság keverékéből épül fel, és az anyagok egymásba átalakulhatnak a természeti folyamatok során. Arisztotelész az élettelen anyagokat is élőnek tekintette, csak sokkal lassabb „életciklussal”. Ebből adódott az a gondolat, hogy a fémek a föld mélyében „növekednek” és egyre nemesebbé válnak – például az ólom idővel arannyá érhet. Az a hit, hogy az anyagok átalakulhatnak egy tökéletesebb formába, az '''alkímia''' eszmerendszerének alapját képezte. Arisztotelész hatalmas tekintélyének köszönhetően az atomelmélet a görög-római világban és a középkori Európában feledésbe merült, és közel két évezreden át az arisztotelészi négyelem-tan uralta a természetről való gondolkodást. A görög tudomány az '''Alexandriai Múzeumban''' (a Kr. e. 3–1. században) találkozott az egyiptomi vegyészeti ismeretekkel. Alexandria városa – melyet Nagy Sándor alapított Kr. e. 331-ben – a hellénisztikus világ kulturális és tudományos központja lett, óriási könyvtárral. Itt dolgoztak az első olyan kutatók, akiket a kémia előfutárainak tekinthetünk. Az alexandriai tudósok örökölték az egyiptomi kézművesek technikai tudását, ismerték és használták a kemencéket, fújtatókat, lepárlókat, ülepítőket és szűrőberendezéseket, tudtak bort és sört készíteni, szappant főzni, üveget és porcelánszerű fajanszt előállítani. Ugyanakkor jártasak voltak a görög filozófiában is, így '''Alexandriában először egyesült a gyakorlati kémia és az elmélet'''. Kísérleteket végeztek új anyagok létrehozására, és az eredményeket lejegyezték: az első „kémiai” kéziratok leírásokat és berendezés-rajzokat is tartalmaztak. Valószínű, hogy maga a „kémia” szó is az alexandriai időkben született meg – egyes feltevések szerint egy kínai eredetű kifejezésből (aranylé) az arab közvetítők által átvéve, innen az arab ''al-kímíá'' és az európai „alkímia/kémia” megnevezés. A görög tudományosság azonban Alexandriában misztikus-esoterikus tanokkal keveredett: keleti (főleg perzsa és indiai) hatásra az ókori tudósok körében terjedni kezdtek az okkult magyarázatok. A görög filozófia, az egyiptomi vegykémia és a keleti miszticizmus elegyéből született meg az '''alkímia''', amely a késő ókortól kezdve hosszú évszázadokra meghatározta az anyagok vizsgálatáról való gondolkodást. Az alkímia elméleti alapját a hagyomány szerint egy titokzatos alexandriai írás, a '''Smaragdtábla''' fektette le, melyet Hermész Triszmegisztosznak (az egyiptomi Thot isten görög megfelelőjének) tulajdonítottak. A Smaragdtábla 13 mondásban foglalja össze az alkímia hitelveit – például azt, hogy ''„ami fent van, ugyanaz, mint ami lent van”'', utalva a makrokozmosz és mikrokozmosz közötti analógiára. Ezek az ezoterikus eszmék nagy hatással voltak a középkori alkimistákra, akik Hermész „fiainak” nevezték magukat. Az alexandriai alkímiai hagyaték a 7. századtól az arab világ közvetítésével maradt fenn és terjedt tovább. <span id="az-alkímia-kora-arab-és-európai-alkímia"></span> == Az alkímia kora (arab és európai alkímia) == '''Az alkímia''' a késő ókorban, Alexandriában alakult ki, majd a középkor folyamán a tudománytörténet fő áramlatává vált. A 7. században az iszlám hódítók elfoglalták Egyiptomot, és hozzáfértek az alexandriai görög kéziratokhoz. A görög-római alkímiai és természettudományos műveket arab nyelvre fordították, ezzel megalapozva az iszlám világ kémiai ismereteit. '''Az arab (iszlám) aranykor alkímiája''' a 8–11. század között élte virágkorát. Az arab alkimisták számos anyagot és kísérleti eszközt ismertek. A nagy perzsa tudós, '''ar-Rázi''' (Rhazes, ~865–925) például rendszerbe foglalta az ismert anyagokat: szerinte vannak állati (pl. vér, tej, epe), növényi (pl. hamu, faszén) és ásványi anyagok. Az ásványokat hat osztályba sorolta: illó „szellemek” (például kén, arzén-szulfid, ammónium-klorid, higany), fémes testek (arany, ezüst, réz, vas, ón, ólom), kövek, vitriolok, bóraxok és sók. Ráadásul részletesen leírta az alkalmazott alkimista '''laboratóriumi felszereléseket''' is: például a kemencét, fújtatót, tégelyt, fogókat, mozsarat, üstöt, mozsárütőt, retortát, hűtőedényt, aludelt, alembiket, szublimálóedényt, lombikot stb.. Ez mutatja, hogy az arab alkimisták nagyon fejlett kísérleti technikákat alkalmaztak a kor viszonyaihoz képest. Ar-Rázi hitt a fémek átalakulásában (úgy vélte, sikerült is ólomból aranyat előállítania), de hangsúlyozta, hogy az alkímiának nem ez az egyetlen célja. A hagyomány az arab alkímia atyjának tartja '''Dzsábir ibn Hajjánt''' (Geber, ~721–815), bár újabb kutatások szerint a „Geber” név alatt fennmaradt mintegy 3000 arab nyelvű alkímiai irat valószínűleg több szerzőtől származik (akiket a későbbi források egységesen Dzsábirnak neveznek). A Dzsábirnak tulajdonított írások rendkívül fejlett kémiai tudást és filozófiát tükröznek. Ötvözik a görög és bizánci alkímiai elméleteket a kínai és indiai alkímiai hagyományokkal. Kifejtik az arisztotelészi négy elem tanát, a fémek két elvű (kén-higany) elméletét, a '''Bölcsek Köve''' segítségével történő fémátalakítás lehetőségét, valamint az emberi egészség és élethossz tökéletesítését egy univerzális '''Elixír''' által. A legendás Bölcsek Köve (latinul ''lapis philosophorum'') nemcsak a nemtelen fémek arannyá változtatását ígérte, hanem az ember testi-lelki tökéletesedését is szimbolizálta. '''Avicenna''' (Ibn Színá, 980–1037), a nagy perzsa polihisztor – bár főként orvosként és filozófusként ismert – szintén írt alkímiáról. Úgy vélte, hogy az összes fém ugyanazon „faj” különböző változatai (azaz nem teljesen különböző anyagok), így elvben lehetséges közöttük az átalakulás, de gyakorlatilag kételkedett abban, hogy az arannyá változtatás sikerülhet. Avicenna e szkepticizmusa már előrevetítette az alkímia lassú átalakulását kémiává. Az arab világ alkimistái számos felfedezést tettek: leírták több sav (például a tömény ecetsav, salétromsav, vitriol (kénsav) és királyvíz) előállítását, tökéletesítették a desztillációt és más labortechnikákat, új elemeket és vegyületeket azonosítottak (például a salétromot és az ammóniát is az arab kémikusok fedezték fel mint különleges anyagokat). Az arab alkimisták 8–11. századi eredményei méltó helyet biztosítanak számukra a kémia fejlődésének történetében, és fontos kapocsként szolgáltak az ókori tudás és az európai tudomány között. A 12. század folyamán az alkímia tudása visszajutott Európába is, nagyrészt az arab tudomány közvetítésével. Ekkoriban latin nyelvre fordították a fontosabb arab alkímiai szövegeket, és megindult a középkori '''európai alkímia''' kibontakozása. Az alkímia egyszerre volt kísérleti tevékenység és misztikus filozófia. Az alkimisták úgy hitték, hogy a fémek „érnek” a föld belsejében, és a nemesfém (az arany) a tökéletes, érett állapotot képviseli. Céljuk a folyamat mesterséges felgyorsítása volt a laboratóriumban, hogy a nem nemes fémeket (pl. ólmot) arannyá változtassák a Bölcsek Köve segítségével. Úgy gondolták, hogy e nagy mű (a ''magnum opus'') véghezvitele nemcsak gazdagságot jelent, de spirituális értelemben is tökéletesíti a kísérlet végrehajtóját. Nem csoda, hogy sokan egész életüket és vagyonukat feláldozták a titok nyomában járva, laboratóriumi kemencéik mellett „puffogtatva és fújtatva”. Az alkímia nyelvezete és jelképrendszere szándékosan homályos és bonyolult volt, hogy titkait az avatottakon kívül más ne értse meg. Az alkimisták számtalan könyvet és kéziratot írtak teli kódolt receptekkel és látomásszerű ábrákkal. Például az „életelixír” egyik receptje így hangzott egy névtelen 15. századi szerzőtől: ''„Végy másfél unciányi nedvességet; a Nap lelkéből (aranyból) egynegyed unciát; ugyanannyi sárga színt; auripigmentumból fél unciát – összesen három uncia. Tudd meg, hogy a bölcsek szőlőjét három részben sajtolják, és bora harminc nap alatt lesz kész.”'' Ilyen és ehhez hasonló rejtjelezett utasításokat próbáltak megfejteni a beavatottak, több-kevesebb sikerrel. Az alkimisták között akadtak őszinte kutatók és kalandor csalók is. Az utóbbiak – az áltudós „pufferek” – fejedelmek és főurak előtt kápráztató trükkökkel mutatták be az aranycsinálást, hogy busás anyagi juttatásokat csaljanak ki. Sok alkimista-szélhámost végül lebukás után kivégeztek (például hamis aranyat készítőket arannyal futtatott akasztófán akasztottak fel). A 16. század végére több európai uralkodó – például II. Rudolf császár Prágában – nyíltan pártfogolta az alkímiát, udvarába gyűjtve a hírneves vagy hírhedt alkimistákat, hogy támogassa kísérleteiket. Prágában az aranycsinálók utcája (Zlatá ulička) máig látható, itt működött több alkimista műhely Rudolf idejében. Az alkímia központjai voltak még a korábbi századokban az olyan kolostorok és egyetemek, mint pl. a 13. századi párizsi és oxfordi iskolák (ahol Roger Bacon is kísérletezett), vagy az itáliai és német fejedelemségek udvarai. '''Paracelsus''' (1493–1541) – a híres orvos és alkimista – a 16. században szakított a hagyományos nézetekkel: elvetette a négy elemet és a fémek kén-higany elvét, helyette három „principiumot” (higany, kén, só) hirdetett, és az alkímiát a gyógyítás szolgálatába állította (''iatrokémia''). Paracelsus a betegségeket kémiai úton, ásványi gyógyszerekkel próbálta orvosolni, ezzel a valódi kémia felé terelte a tudományt. A 17. századra az alkímia tekintélye hanyatlani kezdett, mivel gyakorlati eredményei elmaradtak a nagy ígéretektől. Több új felismerés is megingatta az alkímia alapjait. '''Galileo Galilei''' és '''Evangelista Torricelli''' kísérletei (1643) igazolták a vákuum létezését, így újra napirendre került az atomok létezésének kérdése, amit az alkímia addig tagadott. '''René Descartes''' és a korai természettudósok mechanisztikus világképe pedig kétségbe vonta az alkimisták panteisztikus, „élettel teli” anyagfelfogását. Végül döntő csapást mért az alkímiára a tudományos módszer elterjedése: a 17. század közepétől egy új nemzedék – élükön '''Robert Boyle''' – már a pontos mérésekre és kísérletekre támaszkodó, kritikus szemléletet honosított meg. Ezzel kezdetét vette a modern '''kémia''' kialakulása, és az alkímia lassan átadta helyét az új tudománynak. <span id="a-korai-modern-kémia-boyle-flogisztonelmélet-a-kémiai-elemek-felfedezése"></span> == A korai modern kémia (Boyle, flogisztonelmélet, a kémiai elemek felfedezése) == A 17. század közepére az alkímia fokozatosan '''átalakulóban''' volt: a misztikus-filozófiai elemek háttérbe szorultak, és egyre inkább a kísérleti megfigyelések kerültek előtérbe. Ennek a fordulatnak három fő mozgatórugója volt: (1) az alkímista kísérletek ismétlődő kudarcai a nagy cél (aranycsinálás, életelixír) terén; (2) Torricelli vákuumkísérlete (1643), amely bebizonyította, hogy mégsem „tölt ki mindent” az anyag, tehát az atomok közti üres tér lehetséges; (3) Descartes új, mechanisztikus filozófiája, amely az élettelen anyagban nem tételezett fel életerőt vagy mágikus tulajdonságokat. Ebben a szellemi közegben tevékenykedett '''Robert Boyle''' (1627–1691), akit gyakran a modern kémia első képviselőjének tartanak. Boyle, aki maga is előkelő angol–ír család sarja volt, ifjúkorában alkímiával foglalkozott, de nyitott szellemű, kísérletező alkat lévén hamar túllépett az alkímia dogmáin. Tanulmányozta a gázok viselkedését: levegőpumpát szerkesztett, amellyel részleges vákuumot tudott előállítani, és megvizsgálta a levegő súlyát, rugalmasságát, valamint szerepét az égésben és légzésben. Ő állapította meg a gázok nyomásának és térfogatának fordított arányosságát (Boyle törvénye, 1662): adott hőmérsékleten egy gáz térfogata a nyomással fordítottan arányos. Boyle részt vett a '''Royal Society''' (Angol Királyi Tudós Társaság) megalapításában is (1660), ahol a kor legkiválóbb természettudósai osztották meg egymással kísérleteik eredményeit. Boyle híres munkája, a ''The Sceptical Chymist'' (A szkeptikus kémikus, 1661) már címében is jelzi új szellemiségét. Ebben a könyvben – amelyet párbeszédes formában írt meg – Boyle kísérleti eredmények alapján vitatta az addigi alkímiai tanokat. Kétségbe vonta, hogy az anyagi világ négy elemből állna, ahogy azt az alkímia (és Arisztotelész) tanította, és elutasította Paracelsus három „principiumának” (higany, kén, só) elképzelését is. Boyle szerint az '''elem''' fogalmát újra kell definiálni: szerinte elem azoknak az alkotórészeknek az összessége, amelyekre egy anyagot kémiai úton tovább már nem lehet bontani. Megfigyeléseit gyakran apró, láthatatlan részecskék (korpuszkulumok) mozgásával magyarázta, előrevetítve a későbbi atomos elgondolásokat. Boyle munkássága nyomán a kémia kezdett eltávolodni az alkímiától, és szigorúbb természettudományos alapokra helyezkedett. Boyle korában még számos kutató foglalkozott alkímiával, de már egyre inkább a kémiai kísérletekre koncentráltak. A 17–18. században Európa-szerte sorra fedezték fel az addig ismeretlen '''elemeket''' és '''gázokat''', bár sokáig az alkímia szemléleti keretében magyarázták őket. Az égés és a fémek hevítése jelenségeire a kor vegyészei a '''flogisztonelméletet''' dolgozták ki. Ennek gyökerei a 17. századi '''Johann Becher''' munkáira nyúlnak vissza, de legteljesebb formájában '''Georg Stahl''' német kémikus vezette elő (1702). A flogisztonelmélet szerint minden éghető anyag tartalmaz egy „flogiszton” nevű rejtett anyagot (egy tűz-szerű princípiumot), amely égéskor kiszabadul. Így magyarázták például, hogy ha fát égetünk, a láng a felszabaduló flogiszton megnyilvánulása, a visszamaradó hamu pedig az „anyag flogiszton nélkül” ('''calx'''). A 18. század folyamán ez az elmélet uralta a kémiai gondolkodást, miközben számos fontos felfedezés történt. '''Georg Brandt''' svéd vegyész 1735-ben felfedezte a kobaltot mint új fémes elemet – a kobalt nevű pigmentben találta meg az addig ismeretlen fém komponenst. '''Axel Cronstedt''' 1751-ben a rézércekben található egyik szennyező anyagról kimutatta, hogy valójában új fém, és elnevezte '''nikkelnek'''. (Cronstedt ezzel letette a mineralógia és az analitikai kémia alapjait is.) '''Joseph Black''' skót kémikus 1754-ben izolálta a szén-dioxid gázt, melyet „fix levegőnek” nevezett – felismerte, hogy a mészkő hevítésekor felszabaduló láthatatlan gáz különbözik a levegőtől. 1766-ban '''Henry Cavendish''' angol tudós előállította a hidrogént, amelyet „gyúlékony levegőnek” hívott. Megállapította, hogy ez a gáz színtelen, szagtalan, levegővel robbanó elegyet alkot, és égésekor víz keletkezik – ezzel gyakorlatilag felfedezte, hogy a víz nem elemi anyag, hanem hidrogén és a levegő egy része (később oxigénnek nevezve) alkotja. '''Carl Wilhelm Scheele''' svéd gyógyszerész 1773-ban, majd '''Joseph Priestley''' angol lelkész 1774-ben egymástól függetlenül felfedezték az oxigén gázt (előbbi tűzlevegőnek, utóbbi flogisztikátlan levegőnek nevezte). Priestley számos gázt azonosított (ammóniát, kén-dioxidot, nitrogén-oxidokat stb.), és a szódavíz feltalálása is az ő nevéhez fűződik. Konzervatív szemlélete miatt azonban ragaszkodott a flogisztonelmélethez, és elutasította az új magyarázatokat – emiatt élete végére elszigetelődött a tudományos világban. Rajta kívül azonban több kutató is kételkedni kezdett a flogiszton létezésében. '''Mihail Lomonoszov''' orosz tudós már 1756-ban kimutatta, hogy a fémek kalcifikációja (oxidációja) során súlygyarapodás lép fel, tehát az égés során nem vész el anyag – ezzel a flogisztonelméletet cáfolta, és megfogalmazta a tömegmegmaradás elvét az égési folyamatokra. A flogiszton elmélet végső bukása azonban a 18. század végén következett be, a francia tudós, Lavoisier forradalmi felismerései nyomán. <span id="a-modern-kémia-születése-lavoisier-a-periódusos-rendszer-atomelmélet"></span> == A modern kémia születése (Lavoisier, a periódusos rendszer, atomelmélet) == A 18. század utolsó harmadában zajlott le a '''kémiai forradalom''', amely alapjaiban változtatta meg a kémia tudományát. Ennek központi alakja '''Antoine Laurent de Lavoisier''' (1743–1794) francia tudós volt, akit a modern kémia atyjának is neveznek. Lavoisier zseniális kísérletező volt, aki nagy hangsúlyt fektetett a '''mennyiségi mérésre'''. 1774–79 között végzett híres kísérleteiben kimutatta, hogy az égés valójában egyesülés az egyik levegőalkotó részecskével (amit később oxigénnek nevezett el). Megfigyelte, hogy a foszfor vagy a kén elégetésekor a termék nehezebb, mint a kiindulási anyag, és a tömeggyarapodás a levegőből származik. 1785-re megfogalmazta a '''tömegmegmaradás törvényét''', kimondva, hogy egy kémiai átalakulás során az össztömeg változatlan marad. Lavoisier vizsgálta a víz átalakíthatóságát is: bebizonyította, hogy a víz nem változik „földdé”, ha hosszú ideig forralják egy üvegedényben – a korábban megfigyelt üledék valójában az üveg anyagából vált ki. Priestley kísérleteit megismételve Lavoisier azt is igazolta, hogy a levegő két fő összetevőből áll: egy aktív részből (oxigénből), ami az égést táplálja és a fémeket kalcokra égeti, és egy inert részből (nitrogénből), ami az égést nem támogatja. 1789-ben publikálta fő művét (''Traité Élémentaire de Chimie''), melyben új, modern elveken nyugvó kémiai nevezéktant vezetett be és táblázatba foglalta az '''elemek''' első pontos listáját. Ebben felsorolta mindazon anyagokat, amelyeket kémiai úton nem lehet tovább bontani (pl. oxigén, nitrogén, hidrogén, kén, foszfor, cink, higany), bár néhány téves elemet is tartalmazott a listája (így a hőt (''kalorikum'') és a fényt is elemnek tartotta). Lavoisier az égés jelenségét a flogiszton helyett az oxigénnel magyarázta, és ezzel '''végleg megdöntötte a flogisztonelméletet'''. Munkatársaival (pl. Berthollet, Fourcroy, Guyton) együtt új kémiai nevezéktant dolgozott ki, amely a mai napig használatos (például az oxigén, hidrogén elnevezések tőle származnak). Lavoisier megvizsgálta a kémiai változások hőhatását is: jégkaloriméter segítségével mérte, mennyi hő szabadul fel vagy nyelődik el egyes reakciók során – ezzel megalapozta a termokémia tudományát. A nagy francia forradalom során Lavoisier – aki adószedő is volt – politikai okokból a guillotine áldozata lett (1794), de munkássága óriási hatással volt a kémia további fejlődésére. A kémiai forradalom lényege az volt, hogy a kémia '''szigorú, kvantitatív tudománnyá''' vált: a reakciók mérlegelhetők, a kiinduló anyagok és termékek tömege kiszámítható lett. A kémiai forradalom után a 19. század elején megszilárdult az '''atomelmélet'''. A régi görög atomisztikus eszme új életre kelt: '''John Dalton''' angol kémikus 1803–1808 között kidolgozta az első modern atomelméletet. Feltételezte, hogy minden elem atomokból épül fel, amelyek az adott elemre jellemző tömegűek, és a kémiai reakciók során az atomok új kombinációkba rendeződnek át. Dalton meghatározta jó néhány elem relatív atomtömegét is (a hidrogént 1-nek véve). Munkáját segítették a századfordulón felfedezett törvényszerűségek: '''Joseph Proust''' 1799-ben kimondta a meghatározott súlyviszonyok törvényét (egy adott vegyületben az alkotók tömegaránya állandó), Dalton pedig megfigyelte a többszörös súlyviszonyok törvényét (ha két elem több vegyületet alkot egymással, akkor az egyik elem tömegének rögzített mennyiségéhez a másik elem tömegei kis egész számok arányában viszonyulnak). Ezek a törvények az atomteória bizonyítékául szolgáltak. '''Amadeo Avogadro''' olasz fizikus 1811-ben megkülönböztette az atom és a molekula fogalmát, felismerve, hogy a gázok kétatomos molekulák formájában tartalmazhatják elemi részecskéiket (például az oxigén nem atomok, hanem O₂ molekulák formájában létezik). Avogadro elméletét azonban kezdetben nem fogadták el, és csak 50 évvel később, 1860-ban a karlsruhei kémiai kongresszuson vált általánosan elfogadottá, köszönhetően '''Stanislao Cannizzaro''' munkájának. Cannizzaro és társai egységes rendszert teremtettek az atomtömegek és képletarányok meghatározásában, ami elengedhetetlen alapja volt a kémiai elemek rendszerezésének. '''Jöns Jakob Berzelius''' svéd kémikus eközben (1808–1818) rendkívül pontos atomtömeg-méréseket végzett és bevezette a ma is használt kémiai jelölésrendszert (az elemek egy- vagy kétbetűs szimbólumait). Berzelius számos új elemet is felfedezett (többek közt a szelént, szilíciumot, cériumot, tóriumot), és a vegyérték fogalmát is tőle származtatjuk. A 19. század közepére az ismert elemek száma gyorsan gyarapodott, szükségessé vált azok '''rendszerezése'''. '''Dmitrij Mengyelejev''' orosz kémikus 1869-ben publikálta a periódusos rendszer első változatát. Mengyelejev hitt abban, hogy az elemek tulajdonságai valamilyen természetes rend szerint ismétlődnek. Az addig ismert 66 elemet növekvő atomtömeg szerint sorba rendezte, és észrevette, hogy bizonyos tulajdonságok periodikusan jelentkeznek. Azokat az elemeket, amelyek hasonló tulajdonságokat mutattak, egy oszlopba (csoportba) helyezte. Rendszerének legnagyobb próbaköve az volt, hogy üres helyeket hagyott benne ott, ahol szerinte addig ismeretlen elemeknek kell lenniük. Előre megjósolta e hiányzó elemek atomsúlyát és jellemző tulajdonságait – például az általa ekalumíniumnak és ekaszilíciumnak nevezett elemek később galliumként és germániumként valóban felfedezésre kerültek, méghozzá az általa megadott tulajdonságokkal. Mengyelejev 1871-es periódusos táblázata három ilyen új elemet jövendölt meg, és mindhárom igazolódott: a galliumot 1875-ben, a szkandiumot 1879-ben, a germániumot 1886-ban találták meg és azonosították. E sikerek nyomán a periódusos rendszer széles körben elfogadottá vált, és fokozatosan a kémia egyik legfőbb szervező elvévé nőtte ki magát. (Megjegyzendő, hogy Mengyelejev táblázata az 1860-as években még nem tartalmazhatta a nemesgázokat – azokat Sir William Ramsay fedezte fel később, 1894–98 között. Az elemek rendszerezését végül Moseley 1913-as felfedezése tökéletesítette, aki az atomok ''rendszámán'' alapuló sorba rendezést vezette be az atomtömeg helyett. Ugyanebben az időben Frederick Soddy felismerte, hogy egyes elemeknek többféle atomja is lehet eltérő tömeggel – ezeket nevezte el ''izotópoknak''.) A periódusos rendszer végleg igazolta az atomelméletet és összefüggésbe hozta az elemek atomfelépítését kémiai sajátságaikkal. A 19. század második felére a kémia tudománya szilárd alapokon állt. 1860-ban már nemzetközi kémikuskongresszust tartottak (Karlsruhében), egységesítve a kémiában használt fogalmakat és jelöléseket. A kémikusok előtt ekkor két nagy feladat állt: egyrészt az '''anyagok szerkezetének''' feltárása (molekulák, funkciós csoportok, reakciómechanizmusok megértése), másrészt ezen ismeretek '''alkalmazása''' új anyagok és technológiák létrehozására. Ezzel vette kezdetét a kémia hihetetlen kibontakozása a 19. században. <span id="a-19.-század-kémiai-forradalma-szerves-kémia-analitikai-módszerek-ipari-alkalmazások"></span> == A 19. század kémiai forradalma (szerves kémia, analitikai módszerek, ipari alkalmazások) == A 19. században a kémia tudománya és ipara ugrásszerű fejlődésnek indult, ezért gyakran beszélnek a század '''kémiai forradalmáról'''. Az egyik legfontosabb terület a '''szerves kémia''' felemelkedése volt. Korábban azt gondolták, hogy szerves anyagot (az élő szervezetek anyagait) nem lehet laboratóriumban előállítani (''vis vitalis'' elv), ám '''Friedrich Wöhler''' 1828-ban egy híres kísérlettel megdöntötte ezt a hiedelmet: laboratóriumi úton, szervetlen kiinduló anyagból (ammónium-cianátból) karbamidot (szerves húgysavat) szintetizált. Ez a felfedezés nyitotta meg a kaput a szerves kémia mesterséges úton történő fejlesztése előtt. Hamarosan sorra sikerült előállítani fontos szerves vegyületeket is mesterségesen. '''Justus von Liebig''' és Wöhler 1825-ben felfedezték az izoméria jelenségét (kimutatták, hogy ugyanazon összegképletű, de eltérő szerkezetű vegyületek – például a ciánsav és fulminsav – létezhetnek). 1832-ben azonosították a szerves molekulákban a '''funkciós csoportokat''' és a gyököket, megvetve a strukturális kémia alapját. Liebig emellett megalapozta az '''alkalmazott szerves kémiát''' is: felismerte a növények ásványi táplálkozását, és megalkotta a minimum-törvényt, kimondva hogy a növények növekedését a legkisebb mennyiségben rendelkezésre álló tápanyag korlátozza. Ezzel Liebiget a műtrágyaipar atyjaként is szokták emlegetni. A század közepén '''August Kekulé''' és '''Archibald Couper''' (1858) kidolgozta a kémiai szerkezet fogalmát, és Kekulé később megfejtette a benzol gyűrűs szerkezetét (1865). '''Vladimir Markovnyikov''' orosz kémikus 1869-ben megfogalmazta a szabályt, amely szerint egyes addíciós reakciókban (pl. hidrogén-halogenid addíció alkénekre) a hidrogén mindig ahhoz a szénatomhoz adódik, amelyen eleve több hidrogén volt – ez a Markovnyikov-szabály, ami a szerves reakciók irányát magyarázta. A század végére a szerves kémikusok már több száz szerves vegyületet szintetizáltak, köztük a mindennapi életben fontos anyagokat is. 1856-ban '''William Perkin''' elkészítette az első mesterséges textilfestéket (a lila színű mauveint), amely elindította az anilinfesték-ipart. Sorra jelentek meg az új szintetikus színezékek, mint a magenta (fukszin) és más anilin festékek. 1897-ben '''Felix Hoffmann''' a Bayer gyár laborjában szintetizálta az acetilszalicilsavat (aszpirint), megteremtve a modern gyógyszeripar prototípusát. A 19. század végére a szerves kémiai tudás hatalmasra bővült, és közvetlenül hozzájárult új iparágak – festékipar, gyógyszeripar, robbanóanyag-gyártás stb. – megszületéséhez. A kémia egy másik kulcsfontosságú területe az '''analitikai kémia''' és a '''fizikai kémia''' fejlődése volt. A 19. század elején megjelentek az első elemi analízisek: például '''William Prout''' 1827-ben a biomolekulákat három fő csoportra osztotta (szénhidrátok, fehérjék, zsírok), ami előrevetítette a biokémia alapjait. '''Germain Hess''' 1840-ben megfogalmazta a Hess-tételt, amely kimondja, hogy egy kémiai reakció hőváltozása (reakcióhő) csak a kiinduló és végállapot energiaviszonyaitól függ, nem a reakcióút részleteitől – ezzel lényegében a termodinamika törvényeit alkalmazta kémiai folyamatokra. '''Lord Kelvin''' 1848-ban bevezette az abszolút hőmérsékleti skálát és az abszolút zérus fogalmát, ami a molekuláris mozgás megszűnésének hőmérséklete. '''Louis Pasteur''' 1849-ben felfedezte az optikai izomériát: kimutatta, hogy a borkősavnak van két tükörkép-izomer formája, amelyek forgatják a polarizált fény síkját (ez volt a kiralitás jelenségének első magyarázata). '''August Beer''' 1852-ben megalkotta Beer törvényét, ami leírja az oldatok fényelnyelésének kapcsolatát a koncentrációjukkal – ezzel megalapozta a spektrofotometriát, mint analitikai módszert. '''Bunsen''' és '''Kirchhoff''' 1859-ben feltalálták a spektroszkópiát, amellyel az anyagok fénykibocsátási és elnyelési spektrumát vizsgálva új elemeket fedeztek fel (csézium, rubídium). '''Benjamin Silliman Jr.''' 1855-ben kidolgozta a kőolaj lepárlásának (krakkolásának) módszerét, amely lehetővé tette különféle folyékony üzemanyagok és vegyipari nyersanyagok előállítását a nyersolajból – ezzel megteremtve a modern petrolkémia alapjait. '''Dmitrij Mengyelejev''' periódusos rendszerének 1869-es publikálása a kémiai analízis és az anyagszerkezet megértésének diadalát jelentette. 1877-re '''Josiah Willard Gibbs''' amerikai tudós lefektette a kémiai termodinamika alapjait: bevezette a szabadenergia fogalmát, és megalkotta a Gibbs-féle fázisszabályt, amellyel leírta, hogy a hőmérséklet, nyomás és összetétel hogyan befolyásolja az egyensúlyi fázisok számát egy rendszerben. Gibbs munkája nyomán a kémia ''deduktív, számoló tudománnyá'' vált, hiszen megmutatta, hogy a kémiai folyamatok hajtóereje és egyensúlya kiszámítható az energia és entrópia viszonyából. A 19. század második felében '''Svante Arrhenius''' svéd kémikus megalapozta az elektrolitok ionelméletét (1884), '''Jacob van ’t Hoff''' és '''Wilhelm Ostwald''' pedig a reakciókinetikát és -egyensúlyt vizsgálták – ezzel létrejött a fizikai kémia, mint diszciplína. 1858-ban, a már említett karlsruhei konferencián '''Cannizzaro''' előadásai meggyőzték a kémikusokat Avogadro hipotézisének helyességéről, így ettől fogva általánosan elfogadottá vált, hogy az atomok és molekulák elkülönülnek, és a kémiai képletek valóban tükrözik a molekulák alkotórészeit. A 19. század a '''vegyipar''' születésének időszaka is volt. Az ipari forradalom igényei – textilfestékek, robbanóanyagok, gyógyszerek, műtrágyák stb. – hatalmas lendületet adtak az alkalmazott kémiának. 1791-ben indul az első szódagyár (Leblanc-féle eljárással nátrium-karbonátot gyártva), 1823-ban pedig az első kénsavgyár (ólomkamrás eljárással). 1830–40-es évekre az európai iparban elterjedtek ezek az alapvegyipari folyamatok. A 19. század közepén az Egyesült Királyságban és Németországban felvirágzott az anilinfesték-gyártás (mauvein, fukszin, metilzöld stb. előállítása). '''Alfred Nobel''' 1867-ben feltalálta a dinamitot (szilárd nitroglicerin robbanószert), amely új fejezetet nyitott a bányászatban és haditechnikában. A Nobel által alapított vállalat később a nitroglicerin biztonságos gyártására és nitrocellulóz alapú robbanóanyagokra (lőgyapot, füstnélküli puskapor) is kiterjedt. A '''műtrágyaipar''' Liebig felismerései nyomán indult: előbb a csontokból előállított szuperfoszfát terjedt el (1842), majd a chilei salétromot (nátrium-nitrát) használták tömegesen a talaj tápanyag-utánpótlására. A század végén a villamos energia elterjedése új lehetőségeket teremtett az elektrolízises kémiai gyártásokra: '''Henri Moissan''' 1886-ban elektromos kemencével állított elő kalcium-karbidot, '''Hall''' és '''Héroult''' pedig ugyanebben az évben egymástól függetlenül kifejlesztették az alumínium elektrolitos előállítását timföldből kriolit olvadékában. A kőolaj-finomítás is iparrá fejlődött: az 1850-es évektől petróleumot desztilláltak világításra, az 1880-as évektől pedig a benzin és gázolaj vált fontossá az új belső égésű motorok üzemanyagaként. Az olajipar melléktermékeiből (pl. toluol, fenol) új szerves vegyipari termékek születtek, beleértve a műanyagipar korai előfutárait (celluloid, bakelit). '''Leo Baekeland''' 1907-ben találta fel a bakelitet, az első kemény, teljesen szintetikus műanyagot. A 19. század vége felé a vegyipar termékei gyökeresen átalakították a mindennapi életet: megjelentek a szintetikus '''műszálak''', a modern '''festékek''', a jó minőségű '''mosószerek''', a könnyen elérhető '''gyógyszerek''' és '''fertőtlenítők''', a hatékony '''robbanóanyagok''' és az olcsó '''műtrágyák'''. A vegyipar egyre nagyobb méretekben termelt: kialakult a '''kémiai nagyüzem''' és a '''kémiai gépészet''' (kémiai technológia), hogy ezeket a folyamatokat hatékonyan, biztonságosan és gazdaságosan lehessen megvalósítani. Összességében a 19. század végére a kémia tudománya és ipara meghatározó jelentőségűvé vált. A tudósok megértették az anyagok szerkezetét, felismerték a kémiai reakciók törvényeit, és több tucatnyi elemet izoláltak, illetve mintegy tízezer vegyületet azonosítottak vagy mesterségesen előállítottak. A kémia szorosan összefonódott más természettudományokkal (fizikával, biológiával), és a '''20. század hajnalára''' készen állt arra, hogy belépjen a molekulák mélyebb világába az új eszközök és elméletek segítségével. <span id="a-20.-század-és-napjaink-kémiája-fizikai-kémia-kvantumkémia-biokémia-környezeti-kémia-nanotechnológia-nobel-díjasok"></span> == A 20. század és napjaink kémiája (fizikai kémia, kvantumkémia, biokémia, környezeti kémia, nanotechnológia, Nobel-díjasok) == A 20. század elején a kémia tudománya egyesült a fizikával: megszületett az '''atomfizika''' és a '''kvantummechanika''', amelyek forradalmasították az anyagszerkezet megértését. 1905-ben '''Albert Einstein''' a Brown-mozgás magyarázatával kísérletileg is bizonyította az atomok és molekulák létezését (mérhetővé téve az Avogadro-számot). 1911-ben megrendezték az első ''Solvay-konferenciát'' Brüsszelben, ahol a kor legnagyobb elméleti tudósai – fizikusok és kémikusok – vitatták meg az anyag természetének kérdéseit. '''Ernest Rutherford''' 1911-ben felfedezte az atom pozitív töltésű apró magját, ezzel megalkotta a szórási kísérletei alapján a nukleáris atommodellt. '''Niels Bohr''' dán fizikus 1913-ban egyesítette Rutherford atomképét a kvantumelmélettel: a híres ''Bohr-modellben'' feltételezte, hogy az elektronok meghatározott energiájú pályákon keringenek a mag körül, és csak kvantumugrásokkal válthatnak pályát. Így magyarázta a hidrogénatom vonalas színképét is. Bohr és kortársai munkája nyomán a kémia '''kvantumkora''' kezdetét vette. A kvantummechanika 1925–27 közötti kidolgozása (''Heisenberg'', ''Schrödinger'', ''Dirac'' és mások által) megadta a molekulák elektron szerkezetének elméleti leírását. '''Gilbert N. Lewis''' amerikai vegyész már 1916-ban felvetette a kovalens kötés elektronpár-elméletét (Lewis-féle elektronpár: két atom közös elektronpárral alkot kötést). Lewis vezette be az atomok vegyértékelektronjainak fogalmát és a '''Lewis-féle elektronszerkezet''' jelölését (pontokkal az elem szimbóluma körül) a molekulaképletekben. 1923-ban kidolgozta az elektronpár-donor/akceptor sav-bázis elméletet is (Lewis-féle savak és bázisok). Ezzel párhuzamosan '''Irving Langmuir''' népszerűsítette a vegyértékelektron-koncepciót, és bevezette a „kovalens kötés” kifejezést (1920). A kvantummechanika segítségével '''Linus Pauling''' és más kémikusok a 20. század közepére kidolgozták a molekulapálya-elméletet és a modern kötéselméletet – Pauling 1939-ben megjelent ''A kémiai kötés természete'' című munkája már teljesen a kvantummechanika nyelvén írta le a molekulákat. A fizika és kémia integrációja olyannyira teljessé vált, hogy a 20. század közepére a kémikusok az anyag tulajdonságait az atomok elektronstruktúrájából vezették le. A század második felében a kvantitatív számítási módszerek is megjelentek a kémiában: '''H. C. Brown''', '''Kennet Wade''' és mások elméleti modelleket dolgoztak ki a reakciómechanizmusokra, '''John Pople''' pedig 1970-ben létrehozta a Gaussian számítógépes programot, amely lehetővé tette molekulák kvantumkémiai számítását – forradalmasítva ezzel a kémiai kutatást. A 20. század végére a kémikusok már számítógépes modellezéssel, pontos kvantumkémiai módszerekkel is vizsgálhatták molekulák millióit, ami teljesen új dimenziót nyitott a kutatásban. A 20. században a kémia és a biológia határán létrejött a '''biokémia''' és a '''molekuláris biológia''' tudománya. Ennek gyökerei a 19. századig nyúltak vissza (Liebig állati kémiai kutatásai, Pasteur erjedésvizsgálatai), de a századfordulón vett nagy lendületet. 1897-ben '''Eduard Buchner''' felfedezte, hogy az élesztő kivonata (sejtek nélkül) is képes az alkoholos erjedésre – ezzel kimutatta, hogy a biokémiai folyamatokat specifikus fehérjék, enzimek katalizálják. 1907-re '''Emil Fischer''' és tanítványai feltárták számos fehérje építőegységeit (aminosavakat), és Fischer javasolta a „kulcs-zár” modell analogiáját az enzim-működés magyarázatára. 1926-ban '''James Sumner''' először kristályosított enzimet (ureázt), bizonyítva, hogy az enzimek ténylegesen fehérjék. 1944-ben '''Oswald Avery''' és munkatársai felismerték, hogy az öröklődés anyaga a DNS. 1953-ban '''Watson''' és '''Crick''' – részben kémiai (röntgendiffrakciós) adatok alapján, melyeket '''Rosalind Franklin''' szolgáltatott – megfejtették a DNS kettőshélix szerkezetét. Ezzel kezdetét vette a molekuláris genetika kora. A biokémia a 20. század során hatalmas területté fejlődött: feltárták az anyagcsere útvonalakat (citromsavciklus, fotoszintézis stb.), a fehérjeszerkezeteket (például 1960-ra az első fehérjék térszerkezetét – hemoglobin, mioglobin – meghatározták röntgenkrisztallográfiával), és megjelent a géntechnológia (1973-ban Cohen és Boyer elvégezték az első DNS rekombinációt baktériumokban). A biokémiai ismeretek közvetlen gyakorlati haszna óriási lett: kifejlesztették az antibiotikumokat (1928-ban Fleming felfedezte a penicillint, melyet 1940-es évekre tömegesen gyártottak), a vitaminkészítményeket (Szent-Györgyi Albert 1930-ban izolálta a C-vitamint, 1937-ben Nobel-díjat kapott), az oltóanyagokat és számos egyéb gyógyszert. A 20. század közepére létrejött a '''biotechnológia''': ipari méretekben termeltek mikrobákkal vegyületeket (pl. citromsavat, antibiotikumokat), és a 70-es évektől géntechnikával állítottak elő humán fehérjéket (inzulin, növekedési hormon) mikroorganizmusok segítségével. A biokémia és orvosi kémia fejlődése rengeteg Nobel-díjat eredményezett – a kémiai Nobel-díjasok között igen sok a biokémikus (például 1946-ban és 1947-ben is enzimek felfedezéséért osztottak díjat, 1958-ban a DNS egyik építőelemének, a koenzim-A-nak a feltárásáért, 1962-ben a DNS szerkezetéért, 1964-ben a fehérjeszintézis genetikai kódjának felderítéséért stb.). A kémia ipari és társadalmi hatásai a 20. században tovább nőttek, de megjelentek a '''környezeti problémák''' is. A II. világháború után a vegyipar robbanásszerű fejlődése és a műtrágyák, peszticidek, műanyagok tömeges használata számos kedvezőtlen mellékhatással járt. 1962-ben '''Rachel Carson''' amerikai biológusnő megírta ''Néma tavasz'' című könyvét, amely felhívta a figyelmet a növényvédő szerek – különösen a DDT – túlzott és felelőtlen alkalmazásának veszélyeire. Carson tudományos igényességű, mégis közérthető műve mérföldkő lett: hatására széleskörű társadalmi vita indult a kémiai anyagok környezetre gyakorolt hatásáról, és végül betiltották a DDT-t. A ''Néma tavasz'' nyomán született meg a modern környezetvédelmi mozgalom, és a kémikusok szemlélete is megváltozott: előtérbe került a '''környezetkímélő (zöld) kémia''', melynek lényege a biztonságosabb, nem mérgező alapanyagok és eljárások alkalmazása, a hulladék minimalizálása és az energiahatékonyság növelése. A környezeti kémia és analitika fejlődése révén az 1970-es évekre kimutatták a szmogot okozó vegyületek hatásait, a savas eső jelenségét, a freon gázok ózonréteg-pusztító hatását stb. A nemzetközi összefogás eredményeként 1987-ben betiltották az ózonkárosító klórozott fluorozott szénhidrogéneket (Montreáli Jegyzőkönyv), és sikerült megállítani az ózonréteg vékonyodását. A zöld kémia ma már a kémiai kutatás és oktatás integráns része, és a fenntartható fejlődés fontos pillére. A 20. század végén a kémikusok egyre kisebb léptékben kezdtek gondolkodni: kialakult a '''nanotechnológia'''. 1985-ben '''Harold Kroto''', '''Richard Smalley''' és '''Robert Curl''' felfedezte a szén egy új allotrópját, a '''fulleréneket''', köztük a C₆₀ molekulát, amelyet jellegzetes, focilabda alakú szerkezete nyomán buckminsterfullerénnek neveztek el. 1991-ben '''Iijima Szumio''' elektronmikroszkóppal észlelte a szénnanocsöveket, a hengeres fulleréneket. A nanotechnológia lényege, hogy az anyagok 1–100 nanométeres mérettartományban egészen új tulajdonságokat mutathatnak (pl. egy nano-részecske másképp olvad, más színt ad, más a reakciókészsége, stb.). A 21. század elejére a nanokémia és nanoanyagok kutatása az egyik legaktívabb területté vált: nanoméretű katalizátorok, szenzorok, gyógyszer-hordozó nanorészecskék, grafén és egyéb 2D-anyagok, kvantumpöttyök stb. kerültek kifejlesztésre. A nanotechnológia a számítástechnika fejlődéséhez is hozzájárult (például az egyre kisebb félvezető eszközök előállításával). '''A kémia Nobel-díjasai.''' A 20. század elejétől a kémia tudományának eredményeit a Nobel-díjakkal ismerik el (1901-ben adták át az első kémiai Nobel-díjat, Jacobus van ’t Hoffnak a kémiai dinamikában és ozmózisnyomás terén elért eredményeiért). Azóta minden évben számos kiváló felfedezés nyert elismerést. 1918-ban például '''Fritz Haber''' kapott kémiai Nobelt az ammónia szintéziséért (Haber–Bosch-eljárás), amellyel műtrágyát lehet nagy tömegben előállítani – e találmány nélkülözhetetlen a modern mezőgazdasághoz, és a becslések szerint a világ élelmiszer-termelésének közel fele az így gyártott műtrágyákon alapul. 1931-ben '''Szent-Györgyi Albert''' kapott orvosi Nobelt a C-vitamin felfedezéséért és a sejtlégzés kutatásáért. 1954-ben '''Linus Pauling''' részesült Nobel-díjban a kémiai kötés elmélyült magyarázatáért kvantumkémiai módszerekkel. 1962-ben '''Max Perutz''' és '''John Kendrew''' a fehérjék (hemoglobin és mioglobin) szerkezetének felderítéséért nyerte el a díjat. 1981-ben '''Olah György''' (George Olah) magyar származású kémikus kapott Nobel-díjat a karbokationok kutatásáért. 1995-ben a környezeti kémia terén osztottak díjat: '''Paul Crutzen''', '''Mario Molina''' és '''F. Sherwood Rowland''' kapták az ózonréteg lebomlásának megértéséért. 2016-ban a nanotechnológia úttörőit (molekuláris gépek létrehozói: Sauvage, Stoddart, Feringa) jutalmazták. A Nobel-díjak története így szorosan összefonódik a kémia 20–21. századi fejlődésével – a díjazottak névsora szinte ''summája'' a kémia legfontosabb vívmányainak. A '''21. század elején''' a kémia továbbra is központi szerepet játszik a tudomány és a technológia frontvonalában. Új kihívások jelentek meg, mint a megújuló energiaforrások kémiai megoldásai (akkumulátorok, hidrogéntechnológia), az éghajlatváltozás mérséklése (szén-dioxid megkötése, zöld kémiai eljárások), az új anyagok és gyógyszerek tervezése számítógépes módszerekkel, vagy épp a világűr kémiai kutatása (asztrókémia). A kémia ma ''interdiszciplináris tudomány'': szoros kapcsolatban áll a fizika, biológia, orvostudomány, anyagtudomány, környezettudomány számos ágával. Ugyanakkor megőrizte sajátos jellegét: a '''központi tudomány''' szerepét tölti be, összekapcsolva az alaptudományos ismereteket a gyakorlati alkalmazásokkal. A kémia története az ókori kezdetektől napjainkig azt mutatja, hogy az anyag szerkezetének és átalakíthatóságának megértése alapvető fontosságú volt civilizációnk fejlődésében, és az is marad a jövőben is. '''Források:''' A válasz összeállításához felhasználtuk a kémia történetének számos szakirodalmi forrását és összefoglalását, többek között Andrew E. Z. Szydlo: ''The Beginnings of Chemistry: from ancient times until 1661'' c. munkáját (Pure Appl. Chem., 2022), a Wikipedia vonatkozó szócikkeit (pl. ''History of Chemistry'', ''Kémia – történet''), valamint az ACS (American Chemical Society) és más tudománytörténeti áttekintéseket. {{engl}} {{History of chemistry}} {{Branches of chemistry}} 661yu6fpnktk8gis0hvyrzkp6tbg9pp