Begriffe im Software Engineering, Icon

Begriffe im Software Engineering (und der Softwarearchitektur) Alphabetisch sortiert

  1. Abnah­me
  2. → Abnah­me­kri­te­ri­en (auch: → Akzep­tanz­kri­te­ri­en)
  3. → Abnah­me­test
  4. Abs­trak­ti­on
  5. ADR (Archi­tec­tu­ral Decis­i­on Record)
  6. Agil, → Agi­le (auch: → Agi­li­tät)
  7. Agi­les → Requi­re­ments Engineering
  8. Agi­li­tät, sie­he Agil
  9. Aggre­ga­ti­on
  10. Akteur
  11. Akti­vi­tät
  12. Akti­vi­täts­dia­gramm
  13. Akti­vi­täts­mo­dell
  14. Akzep­tanz­kri­te­ri­en, sie­he Abnahmekriterien
  15. Allein­stel­lungs­merk­mal
  16. Ana­ly­se­mus­ter (auch: Ana­ly­sis Pattern)
  17. Änder­bar­keit
  18. → Ände­rungs­an­trag (auch: → Chan­ge Request)
  19. → Ände­rungs­ma­nage­ment
  20. Ände­rungs­ra­te
  21. Anfor­de­rung
  22. Anfor­de­rungs­ana­ly­se
  23. Anfor­de­rungs­art
  24. → Anfor­de­rungs­at­tri­bu­te
  25. Anfor­de­rungs­ba­sis­li­nie
  26. Anfor­de­rungs­do­ku­ment
  27. → Anfor­de­rungs­er­mitt­lung, sie­he Ermitt­lung (von Anforderungen)
  28. → Anfor­de­rungs­lis­te
  29. → Anfor­de­rungs­ma­nage­ment
  30. Anfor­de­rungs­mo­dell
  31. Anfor­de­rungs­spe­zi­fi­ka­ti­on
  32. Anwen­dungs­be­reich
  33. Anwen­dungs­do­mä­ne, sie­he Problemdomäne
  34. → Anwen­dungs­fall, sie­he → Use Case
  35. Anwen­dungs­fall­dia­gramm, sie­he Use Case Diagramm
  36. Anwen­dungs­fall­mo­dell, sie­he Use Case Modell
  37. Arbeits­er­geb­nis, sie­he Arbeitsprodukt
  38. Arbeits­pro­dukt (auch: Arbeitsergebnis)
  39. Arc42
  40. Archi­tek­tur
  41. → Arte­fakt
  42. Asso­zia­ti­on
  43. Asyn­chro­no­us Programming
  44. Attrap­pe (eines digi­ta­len Sys­tems), sie­he Mock-Up
  45. Attrap­pe, sie­he Nati­ver → Pro­to­typ
  46. Attri­but
  47. Attri­bu­tie­rungs­sche­ma
  48. Auf­ga­be
  49. Auf­trags­be­stand, sie­he → Back­log
  50. → Auf­wand
  51. Auf­wand­schät­zung, sie­he → Schät­zung
  52. Authen­ti­fi­zie­rung
  53. Auto­ri­sie­rung
  54. Back­log (auch: Auftragsbestand)
  55. → Base­line, sie­he → Basis­li­nie
  56. Basis­li­nie (auch: Baseline)
  57. Bedarf
  58. Beha­vi­or-Dri­ven Deve­lo­p­ment – BDD
  59. Benutz­bar­keit
  60. Benut­zer
  61. Benut­zer­an­for­de­rung
  62. Benut­zer­ge­schich­te, sie­he → User Story
  63. → Beschaf­fung
  64. → Best Practice
  65. Big design up front – BDUF
  66. Branch
  67. Bug, sie­he Defekt
  68. Busi­ness Analyse
  69. Busi­ness Analyst
  70. → Busi­ness Case
  71. Caching
  72. → Chan­ge­log
  73. Chan­ge Request, sie­he Änderungsantrag
  74. Check­lis­te
  75. Cla­im Management
  76. Clean Code
  77. Cloud Com­pu­ting
  78. Code
  79. Code Free­ze
  80. Code → Review
  81. Code Smell
  82. Com­mer­cial of the Shelf – COTS
  83. Com­mit
  84. Com­pi­ler
  85. Con­cur­ren­cy (Neben­läu­fig­keit)
  86. Con­cur­ren­cy Issue (Race Condition)
  87. Con­ti­nuous Deli­very / Deploy­ment – CD
  88. Con­ti­nuous Inte­gra­ti­on – CI
  89. Cross Cut­ting Con­cerns – CCC
  90. Cross-Site Request For­gery – CSRF
  91. Data Dic­tion­a­ry
  92. Daten
  93. Daten­bank
  94. Daten­bank­sche­ma
  95. Daten­fluss
  96. → Daten­fluss­dia­gramm
  97. Daten­fluss­mo­dell
  98. Daten­mo­dell
  99. Debug­ging
  100. Decla­ra­ti­ve Programming
  101. Defekt (Bug)
  102. Deploy­ment
  103. Design (auch: Gestaltung)
  104. → Design Freeze
  105. Design Pat­tern
  106. DevOps
  107. Dienst, sie­he Service
  108. Docker / Containerization
  109. Doku­ment­vor­la­ge
  110. Domain Dri­ven Design – DDD
  111. Domä­ne
  112. Domä­nen­an­for­de­rung
  113. Domä­nen­mo­dell
  114. Draht­mo­dell (Im SE-Kon­text sinn­ge­mäß oft bes­ser: Papier-und-Blei­stift-Modell), sie­he Wireframe
  115. DRY – Don’t Repeat Yourself
  116. Durch­sicht, sie­he Review
  117. Durch­spra­che, sie­he Walkthrough
  118. → Effek­ti­vi­tät
  119. → Effi­zi­enz
  120. Ein­deu­tig­keit (von Anforderungen)
  121. Ein­hal­tung (auch: Erfüllung)
  122. Ele­ment (je nach Kon­text auch: Objekt)
  123. Ele­ment, sie­he Entität
  124. Emer­gen­tes Design
  125. Encryp­ti­on (auch: Verschlüsselung)
  126. End­be­nut­zer
  127. End-to-End-Test (E2E-Test)
  128. Enti­tät (auch: Ele­ment, Etwas, Gegenstand)
  129. Enti­ty-Rela­ti­onship Diagramm
  130. Enti­ty-Rela­ti­onship Modell – ERM
  131. Ent­schei­dungs­ta­bel­le
  132. Ent­wick­lung
  133. → Ent­wick­lungs­sta­di­um
  134. Ent­wurf
  135. Epic (auch: Erzählung)
  136. Erar­bei­tung (von Anforderungen)
  137. Erfül­lung, sie­he Einhaltung
  138. Erkun­dung, sie­he Spike
  139. Erle­di­gungs­dia­gramm, sie­he Burn­down Chart
  140. Ermitt­lung (von Anfor­de­run­gen) (auch Anforderungsermittlung)
  141. Erzäh­lung, sie­he Epic
  142. Evo­lu­tio­nä­rer Prototyp
  143. Explo­ra­ti­ver Prototyp
  144. → Fea­ture (auch: Merkmal)
  145. Fea­ture­dia­gramm (auch: Merkmalsdiagramm)
  146. → Fea­ture Freeze
  147. Fea­ture­mo­dell (auch: Merkmalsmodell)
  148. → Feh­ler
  149. Feh­ler­ra­te
  150. → Feh­ler­schwe­re
  151. Feh­ler­to­le­ranz
  152. For­mu­larscha­blo­ne, sie­he Formularvorlage
  153. For­mu­lar­vor­la­ge (auch: Formularschablone)
  154. Frame­work
  155. Free­ze
  156. Frei­ga­be, sie­he Release
  157. Func­tion­al Pro­gramming (FP)
  158. Funk­tio­na­le Anforderung
  159. Funk­tio­na­li­tät
  160. Gar­ba­ge Collection
  161. Gene­ra­li­sie­rung
  162. Geschäfts­an­for­de­rung
  163. Geschäfts­an­for­de­rung, sie­he Busi­ness Case
  164. Gestal­tung, sie­he Design
  165. Git
  166. → Glos­sar
  167. Gra­ph­QL
  168. Hom­onym
  169. Hori­zon­ta­le → Ver­folg­bar­keit
  170. IaaS (Infra­struc­tu­re as a Service)
  171. IDE (Inte­gra­ted Deve­lo­p­ment Environment)
  172. Idem­po­tenz
  173. Impe­ra­ti­ve Programming
  174. → Index
  175. Infor­ma­ti­ons­mo­dell
  176. Inkre­ment (in der → Soft­ware­ent­wick­lung)
  177. Inspek­ti­on
  178. Inte­gra­ti­on
  179. Inte­gra­ti­ons­test
  180. Inter­es­sen­eig­ner, sie­he → Stake­hol­der
  181. Inter­es­sen­eig­ner­an­for­de­rung, sie­he Stakeholderanforderung
  182. Inter­net of Things – IOT
  183. Inter­pre­ter
  184. Ite­ra­ti­on
  185. JWT (JSON Web Token)
  186. → Kan­ban
  187. Kap­se­lung
  188. Kar­di­na­li­tät
  189. KISS (Keep It Simp­le and Stupid)
  190. Klas­se
  191. Klas­sen­dia­gramm
  192. Klas­sen­mo­dell
  193. Kohä­si­on
  194. Kom­po­nen­te
  195. Kom­po­nen­ten­an­for­de­rung
  196. Kom­po­nen­ten­schnitt­stel­le
  197. → Kom­ple­xi­tät
  198. Kom­po­si­ti­on (in einem tech­ni­schen Kontext)
  199. → Kon­fi­gu­ra­ti­on
  200. → Kon­fi­gu­ra­ti­ons­ma­nage­ment
  201. Kon­for­mi­tät
  202. Kon­sis­tenz (von Anforderungen)
  203. Kon­text
  204. Kon­text­dia­gramm
  205. Kon­text­gren­ze
  206. Kon­text­mo­dell
  207. Kon­troll­fluss, sie­he Steuerfluss
  208. Kon­zept
  209. Kopp­lung
  210. Kor­rekt­heit
  211. Kos­ten
  212. Kuber­netes (K8s)
  213. → Kun­de
  214. Kun­den­zu­frie­den­heit
  215. → Las­ten­heft
  216. Leis­tung
  217. Leis­tungs­an­for­de­rung
  218. Libra­ry (Biblio­thek)
  219. → Lie­fe­rant
  220. Lin­ting / Linter
  221. Log­ging
  222. Lösung
  223. Lösungs­mo­dell
  224. Lösungs­spe­zi­fi­ka­ti­on, sie­he → Pflich­ten­heft
  225. Mach­bar­keit (einer Anforderung)
  226. Markt
  227. Markt­an­for­de­rung
  228. Mehr­deu­tig­keit
  229. Memo­ry Leak
  230. Mer­ge
  231. Merk­mal, sie­he Feature
  232. Merk­mals­dia­gramm, sie­he Featurediagramm
  233. Merk­mals­mo­dell, sie­he Featuremodell
  234. Metho­de
  235. Micro­ser­vices
  236. Migra­ti­on
  237. → Mini­mum Via­ble Pro­duct – → MVP
  238. Mock-Up (eines digi­ta­len Sys­tems) (auch: Attrap­pe, Systemattrappe)
  239. Modell
  240. Modell­ba­sier­tes → Sys­tems Engi­nee­ring / Model-based sys­tems engi­nee­ring – MBSE
  241. Model­lie­rungs­spra­che
  242. Mono­lith
  243. Moni­to­ring
  244. Mul­ti­pli­zi­tät
  245. MVC (Model-View-Con­trol­ler)
  246. MVP (Mini­mum Via­ble Product):
  247. Nati­ver Pro­to­typ (auch: Attrap­pe, Pro­to­typ im enge­ren Sinn)
  248. Natür­li­che Sprache
  249. → Nicht-funk­tio­na­le Anforderung
  250. → Norm
  251. Nota­ti­on
  252. NoS­QL
  253. OAuth
  254. Objekt
  255. Objekt­dia­gramm
  256. Objekt­mo­dell
  257. OOP (Objekt­ori­en­tier­te Programmierung)
  258. ORM (Object-Rela­tio­nal Mapping)
  259. PaaS (Plat­form as a Service)
  260. Par­al­le­li­tät
  261. Peer Review
  262. Pfleg­bar­keit, sie­he Wartbarkeit
  263. Pflich­ten­heft, sie­he System-Anforderungsspezifikation
  264. Pipe­line
  265. Por­ta­bi­li­tät
  266. Poly­mor­phie
  267. → Prak­tik
  268. → Prin­zip
  269. → Prio­ri­sie­rung
  270. → Prio­ri­tät
  271. → Pro­blem
  272. Pro­blem­do­mä­ne
  273. Pro­duct Back­log (auch: Produkt-Backlog)
  274. → Pro­duct Owner (auch: Produkteigner)
  275. Pro­dukt (im Kon­text von Software)
  276. Pro­dukt­ent­ste­hungs­pro­zess – PEP
  277. → Pro­duk­ti­vi­tät
  278. Pro­dukt­le­bens­zy­klus (auch: Pro­duct Life Cycle) – PLC
  279. Pro­dukt­li­nie (auch: Produktfamilie)
  280. Pro­dukt­ma­na­ger
  281. Pro­dukt­stra­te­gie
  282. → Pro­dukt­vi­si­on
  283. Pro­to­typ
  284. Pro­to­typ im enge­ren Sinn, sie­he Nati­ver Prototyp
  285. Pro­to­ty­p­ing (auch: Prototypisieren)
  286. Pro­to­ty­pi­sie­ren, sie­he Prototyping
  287. Pro­zess
  288. → Pull Request (PR) / Mer­ge Request
  289. → Qua­li­tät
  290. Qua­li­täts­an­for­de­rung
  291. Qua­li­täts­si­che­rung
  292. Qua­li­täts­ziel
  293. Quel­le (einer Anforderung)
  294. → Rand­be­din­gung (im RE)
  295. Red­un­danz
  296. → Reen­gi­nee­ring
  297. Refak­to­rie­rung (auch: Refactoring)
  298. Regres­si­ons­test
  299. Release (auch: Freigabe)
  300. Repo­si­to­ry
  301. → Requi­re­ments Engi­neer (auch: Anfor­de­rungs­ana­ly­ti­ker, Anforderungsingenieur)
  302. Requi­re­ments Engi­nee­ring (auch: Anforderungstechnik)
  303. → Requi­re­ments Management
  304. → Res­sour­ce
  305. REST (Repre­sen­ta­tio­nal Sta­te Transfer)
  306. → Rever­se Engineering
  307. Review (auch: Durchsicht)
  308. Risi­ko
  309. → Road­map
  310. Rol­le
  311. Round-Trip-Engi­nee­ring
  312. SaaS (Soft­ware as a Service)
  313. → Schät­zen
  314. Scope Manage­ment
  315. → Scrum
  316. SDK (Soft­ware Deve­lo­p­ment Kit)
  317. → Secu­ri­ty
  318. Seman­tik
  319. Sequenz­dia­gramm
  320. Ser­vice (auch: Dienst)
  321. → Ser­vice Level Agree­ment – → SLA
  322. Sicher­heit (im Sinn von → Infor­ma­ti­ons­si­cher­heit)
  323. Sicher­heit (im Sinn von Nutzungssicherheit)
  324. Sicht
  325. Sin­gle Point of Truth (SPOT)
  326. Sin­gle Source of Truth (SSOP), sie­he Sin­gle Point of Truth (SPOT)
  327. Ska­lier­bar­keit
  328. Soft­ware-Anfor­de­rungs­spe­zi­fi­ka­ti­on (auch: Pflichtenheft)
  329. Soft­ware-Metrik
  330. → Soft­ware­test
  331. Source of Truth, sie­he Sin­gle Point of Truth (SPOT)
  332. Spe­zi­fi­ka­ti­on
  333. Spe­zi­fi­ka­ti­on durch Beispiele
  334. Spe­zi­fi­ka­ti­ons­spra­che
  335. Spike (auch: Erkundung)
  336. Spra­che
  337. Sprint
  338. Stake­hol­der (auch: Interesseneigner)
  339. Stake­hol­der­an­for­de­rung (auch: Interesseneigneranforderung)
  340. Stand
  341. Stand der Technik
  342. Sta­te Chart, sie­he Zustandsdiagramm
  343. Steu­er­fluss (auch: Kontrollfluss)
  344. Sto­ry (in einem RE-Kon­text) (auch: Geschichte)
  345. Sto­ry Map (auch: Story-Landschaft)
  346. Sto­ry­board
  347. Sto­ry-Land­schaft, sie­he Sto­ry Map
  348. Struk­tu­rier­te Analyse
  349. SWEBOK
  350. Syn­onym
  351. Syn­tax
  352. Sys­tem
  353. Sys­tem­an­for­de­rung
  354. Sys­tem­at­trap­pe, sie­he Mock-Up
  355. Sys­tem­gren­ze
  356. → Sys­tem­kon­text
  357. Sys­tem­tech­nik
  358. Sys­tem­test
  359. SysML
  360. Sze­na­rio
  361. Sze­na­rio­tech­nik
  362. → Tracea­bi­li­ty
  363. Tech­nik
  364. Teil­for­mal
  365. The­ma­ti­sche Sammlung
  366. Time­box, sie­he Zeitrahmen
  367. Test
  368. → Tes­ten
  369. Test­ob­jekt
  370. Test Dri­ven Deve­lo­p­ment (TDD)
  371. Über­be­stimmt­heit
  372. Über­ein­stim­mung
  373. Umfang (einer Systementwicklung)
  374. → UML
  375. Uni­que Sel­ling Point (USP), sie­he Alleinstellungsmerkmal
  376. Use Case Dia­gramm (auch: Anwendungsfalldiagramm)
  377. Use Case Modell (auch: Anwendungsfallmodell)
  378. Use Case (auch: Anwendungsfall)
  379. User Sto­ry (auch: Benutzergeschichte)
  380. Vali­die­rung
  381. Varia­bi­li­tät
  382. Vari­an­te
  383. Varia­ti­ons­punkt
  384. Ver­ein­ba­rung
  385. Ver­folg­bar­keit, sie­he Traceability
  386. Ver­hal­ten
  387. Ver­hal­tens­mo­dell
  388. Ver­hand­lung von Anfor­de­run­gen, sie­he Abstim­mung von Anforderungen
  389. Veri­fi­ka­ti­on
  390. Veri­fi­zier­bar­keit (von Anfor­de­run­gen), sie­he Prüfbarkeit
  391. Ver­si­on
  392. Ver­steh­bar­keit
  393. Ver­ti­ka­le Verfolgbarkeit
  394. → Visi­on (für ein Sys­tem oder Produkt)
  395. → V‑Modell
  396. Voll­stän­dig­keit (von Anforderungen)
  397. Vor­ge­hens­mo­dell
  398. Walk­th­rough (auch: Durchsprache)
  399. Wart­bar­keit (auch: Pflegbarkeit)
  400. Werk­zeug (im → Soft­ware Engi­nee­ring)
  401. Wie­der­ver­wen­dung
  402. Wire­frame (auch: Draht­mo­dell, Papier-und-Bleistift-Modell)
  403. Wirt­schaft­lich­keit
  404. Work­around
  405. Work­flow
  406. Zeit­rah­men (mit fes­ter Län­ge) (auch: Timebox)
  407. Zer­ti­fi­zie­rung
  408. Ziel
  409. Ziel­mo­dell
  410. Zustands­dia­gramm (auch: Sta­te Chart)
  411. Zustands­ma­schi­ne
  412. Zuver­läs­sig­keit
  413. Zuwei­sung
  414. Zweig

Ähnliche Beiträge