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

Ähnliche Beiträge