{"id":3638,"date":"2026-10-26T09:58:50","date_gmt":"2026-10-26T06:58:50","guid":{"rendered":"https:\/\/niteducation.com\/resources\/?p=3638"},"modified":"2026-10-26T09:58:52","modified_gmt":"2026-10-26T06:58:52","slug":"programming-skills-engineering-students","status":"publish","type":"post","link":"https:\/\/niteducation.com\/resources\/programming-skills-engineering-students\/","title":{"rendered":"Programming Skills Engineering Students Should Learn First"},"content":{"rendered":"\n<!--\nNewton Institute of Technology \u2014 Article 191\nMaster Stylesheet v6 premium visual build \u2014 22 October 2026\nWordPress supplies the page's only semantic H1; this body uses .nit-hero__title.\nLoad the locked NIT-Articles-Master-v6.0.css once at site level.\nNo article-specific CSS, inline styles, scripts, new component classes or infographics are used.\nCanonical production URL: https:\/\/niteducation.com\/resources\/programming-skills-engineering-students\/\nSearch-intent ownership: beginner programming skills for engineering students; what to learn first; Python-first common core; first engineering coding project; field-specific branching.\nCannibalization boundary: Article 190 owns programming applications for civil engineers; Article 189 owns whether engineering students should study Full-Stack Software Development; dedicated NIT course pages own full curricula, fees and admissions detail.\n-->\n<article class=\"nit-article nit-article--pathway-guide nit-article--c-minus nit-article--c-plus-degree nit-article--software\" itemscope itemtype=\"https:\/\/schema.org\/Article\" aria-labelledby=\"nit-article-title\">\n<meta itemprop=\"datePublished\" content=\"2026-10-22\">\n<meta itemprop=\"dateModified\" content=\"2026-10-22\">\n<meta itemprop=\"inLanguage\" content=\"en-KE\">\n<meta itemprop=\"author\" content=\"Newton Institute of Technology Editorial Team\">\n\n<div class=\"nit-hero nit-hero--software\" aria-labelledby=\"nit-article-title\">\n  <div class=\"nit-software-hero__grid\">\n    <div class=\"nit-software-hero__copy\">\n      <p class=\"nit-hero__eyebrow\">Engineering programming roadmap \u00b7 beginner to project<\/p>\n      <p class=\"nit-hero__title\" id=\"nit-article-title\" itemprop=\"headline\">Programming Skills <span>Engineering Students<\/span> Should Learn First<\/p>\n      <p class=\"nit-hero__summary\" itemprop=\"description\">Start with problem-solving and Python, build a working Engineering Calculator, then add numerical computing, data, graphs, version control and the tools your engineering field needs.<\/p>\n      <div class=\"nit-badge-row\" aria-label=\"Programming roadmap highlights\">\n        <span class=\"nit-badge\">Start with Python<\/span>\n        <span class=\"nit-badge\">Build a real project<\/span>\n        <span class=\"nit-badge\">Then specialise by field<\/span>\n      <\/div>\n      <div class=\"nit-hero__actions\">\n        <a class=\"nit-button nit-button--primary\" href=\"#roadmap\">See the learning order<\/a>\n        <a class=\"nit-button nit-button--secondary\" href=\"#first-project\">Build the first project<\/a>\n      <\/div>\n    <\/div>\n    <div class=\"nit-code-window\" aria-label=\"Engineering programming learning roadmap\">\n      <div class=\"nit-code-window__bar\"><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__file\">engineering-roadmap.py<\/span><\/div>\n      <div class=\"nit-code-window__body\"><span class=\"nit-code-line\"><span class=\"nit-code-comment\"># start with a problem you understand<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">problem<\/span> = <span class=\"nit-code-string\">&quot;engineering task&quot;<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">language<\/span> = <span class=\"nit-code-string\">&quot;Python&quot;<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">learn<\/span> = [<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-string\">&quot;logic&quot;<\/span>, <span class=\"nit-code-string\">&quot;functions&quot;<\/span>,<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-string\">&quot;debugging&quot;<\/span>, <span class=\"nit-code-string\">&quot;data&quot;<\/span><\/span><span class=\"nit-code-line\">]<\/span><span class=\"nit-code-line\"><span class=\"nit-code-comment\"># build \u2192 test \u2192 explain \u2192 improve<\/span><\/span><\/div>\n    <\/div>\n  <\/div>\n  <div class=\"nit-pg-hero__meta\" aria-label=\"Article preparation and technical review\">\n    <p><span>Prepared by<\/span>Newton Institute of Technology Editorial Team<\/p>\n    <p><span>Institutional \/ Technical review<\/span>Engineer Simon Barongo<\/p>\n    <p><span>Audience<\/span>School leavers \u00b7 engineering students \u00b7 beginners<\/p>\n    <p><span>Last reviewed<\/span>22 October 2026<\/p>\n  <\/div>\n<\/div>\n\n<div class=\"nit-article__body\" itemprop=\"articleBody\">\n<section class=\"nit-pg-answer\" aria-labelledby=\"quick-answer-heading\">\n  <div class=\"nit-pg-answer__question\"><span>Quick answer<\/span><h2 id=\"quick-answer-heading\">What programming should an engineering student learn first?<\/h2><\/div>\n  <p>Start with <strong>problem-solving and Python<\/strong>. Learn variables, calculations, conditions, loops and functions; use them to build a small engineering application; then add NumPy and SciPy for numerical work, pandas for tabular data, Matplotlib for graphs, Jupyter for explained calculations and Git for version control. After that common core, choose the next language or tool according to your engineering field. Python&#8217;s official tutorial introduces numbers, lists, control flow, functions, files and errors as core language concepts. <a href=\"#source-1\">[1]<\/a><\/p>\n<\/section>\n\n<div class=\"nit-cm-snapshot\" aria-label=\"Programming roadmap at a glance\">\n  <div><span>Start here<\/span><strong>Logic + Python<\/strong><small>Learn to turn a formula or technical procedure into clear instructions.<\/small><\/div>\n  <div><span>Build first<\/span><strong>Engineering Calculator<\/strong><small>Combine input, functions, conditions, validation and readable output.<\/small><\/div>\n  <div><span>Then specialise<\/span><strong>Follow your field<\/strong><small>C\/C++ for embedded work, SQL for data-heavy work, deeper numerical tools for modelling.<\/small><\/div>\n<\/div>\n\n<nav class=\"nit-pg-nav\" aria-label=\"Article sections\"><p>Jump to the section you need<\/p><div>\n<a href=\"#roadmap\">Learning roadmap<\/a><a href=\"#logic\">Problem-solving<\/a><a href=\"#python\">Python<\/a><a href=\"#first-project\">Engineering Calculator<\/a><a href=\"#numerical\">Numerical tools<\/a><a href=\"#data\">Data &amp; graphs<\/a><a href=\"#field-branch\">Choose by field<\/a><a href=\"#twelve-weeks\">12-week plan<\/a><a href=\"#faqs\">FAQs<\/a>\n<\/div><\/nav>\n\n<section class=\"nit-pg-section nit-pg-section--comparison\" id=\"roadmap\" aria-labelledby=\"roadmap-heading\">\n  <p class=\"nit-pg-eyebrow\">The learning order<\/p><h2 id=\"roadmap-heading\">Build a common programming core before you specialise<\/h2>\n  <div class=\"nit-pg-table-wrap\" role=\"region\" tabindex=\"0\" aria-label=\"Programming skills engineering students should learn first\">\n    <table class=\"nit-pg-table\"><thead><tr><th scope=\"col\">Stage<\/th><th scope=\"col\">Learn<\/th><th scope=\"col\">Practical target<\/th><\/tr><\/thead><tbody>\n      <tr><th scope=\"row\">1<\/th><td>Problem-solving logic<\/td><td>Turn an engineering problem into ordered steps.<\/td><\/tr>\n      <tr><th scope=\"row\">2<\/th><td>Python fundamentals<\/td><td>Write small calculations using variables, input, conditions and loops.<\/td><\/tr>\n      <tr><th scope=\"row\">3<\/th><td>Functions + debugging<\/td><td>Organise code and correct both coding and engineering mistakes.<\/td><\/tr>\n      <tr><th scope=\"row\">4<\/th><td>First project<\/td><td>Build a working Engineering Calculator.<\/td><\/tr>\n      <tr><th scope=\"row\">5<\/th><td>NumPy + SciPy<\/td><td>Work with arrays and more advanced numerical problems.<\/td><\/tr>\n      <tr><th scope=\"row\">6<\/th><td>pandas + Matplotlib<\/td><td>Analyse tables and turn results into useful graphs.<\/td><\/tr>\n      <tr><th scope=\"row\">7<\/th><td>Jupyter + Git<\/td><td>Document calculations and track project changes.<\/td><\/tr>\n      <tr><th scope=\"row\">8<\/th><td>Field-specific tools<\/td><td>Add C\/C++, SQL, MATLAB or other tools when your engineering work requires them.<\/td><\/tr>\n    <\/tbody><\/table>\n  <\/div><p class=\"nit-pg-table-note\">On a small screen, swipe horizontally to compare all three columns.<\/p>\n<\/section>\n\n<section class=\"nit-pg-section\" id=\"logic\" aria-labelledby=\"logic-heading\">\n  <p class=\"nit-pg-eyebrow\">Step 1 \u00b7 computational thinking<\/p><h2 id=\"logic-heading\">Learn to turn an engineering problem into instructions<\/h2>\n  <p>Programming starts before the first line of code. Take a problem you already understand, identify the known values, identify what must be calculated, check the units, choose the equation and arrange the steps in the correct order.<\/p>\n  <div class=\"nit-pg-reasons\" aria-label=\"Stress calculation problem-solving sequence\">\n    <div><span>01<\/span><h3>Known values<\/h3><p>Force = 120 kN. Cross-sectional area = 2,400 mm\u00b2.<\/p><\/div>\n    <div><span>02<\/span><h3>Target<\/h3><p>Calculate stress using force divided by area.<\/p><\/div>\n    <div><span>03<\/span><h3>Units<\/h3><p>Convert 120 kN to 120,000 N before applying the equation.<\/p><\/div>\n    <div><span>04<\/span><h3>Result<\/h3><p>120,000 \u00f7 2,400 = 50 N\/mm\u00b2 = 50 MPa.<\/p><\/div>\n  <\/div>\n  <div class=\"nit-pg-highlight\"><strong>The coding habit begins here.<\/strong><p>Write the engineering method clearly first. Code becomes much easier when the sequence, units and expected result are already understood.<\/p><\/div>\n<\/section>\n\n<section class=\"nit-pg-section\" id=\"python\" aria-labelledby=\"python-heading\">\n  <p class=\"nit-pg-eyebrow\">Step 2 \u00b7 first language<\/p><h2 id=\"python-heading\">Use Python to turn the method into a working program<\/h2>\n  <p>Python is a practical first language because the same language that handles a beginner calculation can later support scientific computing, data analysis, plotting and automation. The Python documentation describes it as an easy-to-learn, powerful language suited to scripting and rapid application development. <a href=\"#source-1\">[1]<\/a><\/p>\n  <div class=\"nit-deg-band-grid\" aria-label=\"Python fundamentals and first target\">\n    <article class=\"nit-deg-band\"><div class=\"nit-deg-band__head\"><span>Learn first<\/span><h3>Small set of core ideas<\/h3><\/div><ul><li>Variables and data types<\/li><li>Input and output<\/li><li>Mathematical operators<\/li><li><code>if<\/code> conditions<\/li><li><code>for<\/code> and <code>while<\/code> loops<\/li><li>Functions and lists<\/li><\/ul><\/article>\n    <article class=\"nit-deg-band nit-deg-band--competitive\"><div class=\"nit-deg-band__head\"><span>Practical target<\/span><h3>Explain every line you write<\/h3><\/div><ul><li>Choose meaningful variable names.<\/li><li>Keep units visible in names or output.<\/li><li>Test with values you can calculate manually.<\/li><li>Change an input and predict what should happen.<\/li><li>Correct the program when the result is wrong.<\/li><\/ul><\/article>\n  <\/div>\n\n  <div class=\"nit-action-strip\"><p>First calculation: turn the stress equation into a short Python program, then check that the code returns the same 50 MPa result as the manual calculation.<\/p><\/div>\n  <div class=\"nit-code-window\" aria-label=\"Python stress calculation example\">\n    <div class=\"nit-code-window__bar\"><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__file\">stress_calculator.py<\/span><\/div>\n    <div class=\"nit-code-window__body\"><span class=\"nit-code-line\"><span class=\"nit-code-name\">force_kn<\/span> = <span class=\"nit-code-number\">120<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">area_mm2<\/span> = <span class=\"nit-code-number\">2400<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">force_n<\/span> = <span class=\"nit-code-name\">force_kn<\/span> * <span class=\"nit-code-number\">1000<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">stress_mpa<\/span> = <span class=\"nit-code-name\">force_n<\/span> \/ <span class=\"nit-code-name\">area_mm2<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">print<\/span>(<span class=\"nit-code-name\">stress_mpa<\/span>)<\/span><span class=\"nit-code-line\"><span class=\"nit-code-comment\"># output: 50.0 MPa<\/span><\/span><\/div>\n  <\/div>\n\n  <div id=\"first-project\" aria-labelledby=\"project-heading\">\n    <div class=\"nit-action-strip\"><p><strong>Next milestone:<\/strong> combine the basics into one small application.<\/p><\/div>\n    <p class=\"nit-pg-eyebrow\">Your first project<\/p><h3 id=\"project-heading\">Build a Simple Engineering Calculator<\/h3>\n    <p>Start with one calculation, then add input, functions, decisions, validation and repeated values until the same program becomes a small engineering application.<\/p>\n\n    <div class=\"nit-project-grid\" aria-label=\"Engineering Calculator development stages\">\n      <article class=\"nit-project-card\" data-project=\"1\"><h3>One calculation<\/h3><p>Write electrical power as <strong>Power = Voltage \u00d7 Current<\/strong>. The first version can use fixed values.<\/p><span class=\"nit-project-status\">Variables + arithmetic<\/span><\/article>\n      <article class=\"nit-project-card\" data-project=\"2\"><h3>Make it interactive<\/h3><p>Use <code>input()<\/code> so another person can enter voltage and current without editing the source code.<\/p><span class=\"nit-project-status\">Input + output<\/span><\/article>\n      <article class=\"nit-project-card\" data-project=\"3\"><h3>Organise with functions<\/h3><p>Create separate functions for speed, power, stress and density. Each function performs one defined task.<\/p><span class=\"nit-project-status\">Reusable code<\/span><\/article>\n      <article class=\"nit-project-card\" data-project=\"4\"><h3>Add a menu<\/h3><p>Use conditions to select the calculation. Then add validation, repeated values, files and graphs as your skills grow.<\/p><span class=\"nit-project-status\">Complete beginner application<\/span><\/article>\n    <\/div>\n\n    <div class=\"nit-action-strip\"><p><strong>Project step A \u00b7<\/strong> Accept values from the user<\/p><\/div>\n    <div class=\"nit-code-window\" aria-label=\"Interactive electrical power calculator\">\n      <div class=\"nit-code-window__bar\"><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__file\">power.py<\/span><\/div>\n      <div class=\"nit-code-window__body\"><span class=\"nit-code-line\"><span class=\"nit-code-name\">voltage<\/span> = <span class=\"nit-code-keyword\">float<\/span>(<span class=\"nit-code-keyword\">input<\/span>(<span class=\"nit-code-string\">&quot;Voltage (V): &quot;<\/span>))<\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">current<\/span> = <span class=\"nit-code-keyword\">float<\/span>(<span class=\"nit-code-keyword\">input<\/span>(<span class=\"nit-code-string\">&quot;Current (A): &quot;<\/span>))<\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">power<\/span> = <span class=\"nit-code-name\">voltage<\/span> * <span class=\"nit-code-name\">current<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">print<\/span>(<span class=\"nit-code-string\">&quot;Power =&quot;<\/span>, <span class=\"nit-code-name\">power<\/span>, <span class=\"nit-code-string\">&quot;W&quot;<\/span>)<\/span><\/div>\n    <\/div>\n\n    <div class=\"nit-action-strip\"><p><strong>Project step B \u00b7<\/strong> Turn repeated calculations into functions<\/p><\/div>\n    <div class=\"nit-code-window\" aria-label=\"Reusable engineering calculation functions\">\n      <div class=\"nit-code-window__bar\"><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__file\">engineering_functions.py<\/span><\/div>\n      <div class=\"nit-code-window__body\"><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">def<\/span> <span class=\"nit-code-name\">calculate_speed<\/span>(distance, time):<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">return<\/span> distance \/ time<\/span><span class=\"nit-code-line\"><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">def<\/span> <span class=\"nit-code-name\">calculate_power<\/span>(voltage, current):<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">return<\/span> voltage * current<\/span><span class=\"nit-code-line\"><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">def<\/span> <span class=\"nit-code-name\">calculate_stress<\/span>(force, area):<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">return<\/span> force \/ area<\/span><span class=\"nit-code-line\"><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">def<\/span> <span class=\"nit-code-name\">calculate_density<\/span>(mass, volume):<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">return<\/span> mass \/ volume<\/span><\/div>\n    <\/div>\n\n    <div class=\"nit-action-strip\"><p><strong>Project step C \u00b7<\/strong> Combine the pieces into an application<\/p><\/div>\n    <div class=\"nit-code-window\" aria-label=\"Beginner engineering calculator application\">\n      <div class=\"nit-code-window__bar\"><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__file\">engineering_calculator.py<\/span><\/div>\n      <div class=\"nit-code-window__body\"><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">def<\/span> <span class=\"nit-code-name\">calculate_power<\/span>(voltage, current):<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">return<\/span> voltage * current<\/span><span class=\"nit-code-line\"><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">def<\/span> <span class=\"nit-code-name\">calculate_stress<\/span>(force, area):<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">return<\/span> force \/ area<\/span><span class=\"nit-code-line\"><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">print<\/span>(<span class=\"nit-code-string\">&quot;1. Electrical Power&quot;<\/span>)<\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">print<\/span>(<span class=\"nit-code-string\">&quot;2. Stress&quot;<\/span>)<\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">choice<\/span> = <span class=\"nit-code-keyword\">input<\/span>(<span class=\"nit-code-string\">&quot;Choose 1 or 2: &quot;<\/span>)<\/span><span class=\"nit-code-line\"><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">if<\/span> choice == <span class=\"nit-code-string\">&quot;1&quot;<\/span>:<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-name\">voltage<\/span> = <span class=\"nit-code-keyword\">float<\/span>(<span class=\"nit-code-keyword\">input<\/span>(<span class=\"nit-code-string\">&quot;Voltage (V): &quot;<\/span>))<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-name\">current<\/span> = <span class=\"nit-code-keyword\">float<\/span>(<span class=\"nit-code-keyword\">input<\/span>(<span class=\"nit-code-string\">&quot;Current (A): &quot;<\/span>))<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">print<\/span>(<span class=\"nit-code-string\">&quot;Power =&quot;<\/span>, <span class=\"nit-code-name\">calculate_power<\/span>(voltage, current), <span class=\"nit-code-string\">&quot;W&quot;<\/span>)<\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">elif<\/span> choice == <span class=\"nit-code-string\">&quot;2&quot;<\/span>:<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-name\">force<\/span> = <span class=\"nit-code-keyword\">float<\/span>(<span class=\"nit-code-keyword\">input<\/span>(<span class=\"nit-code-string\">&quot;Force (N): &quot;<\/span>))<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-name\">area<\/span> = <span class=\"nit-code-keyword\">float<\/span>(<span class=\"nit-code-keyword\">input<\/span>(<span class=\"nit-code-string\">&quot;Area (mm\u00b2): &quot;<\/span>))<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">print<\/span>(<span class=\"nit-code-string\">&quot;Stress =&quot;<\/span>, <span class=\"nit-code-name\">calculate_stress<\/span>(force, area), <span class=\"nit-code-string\">&quot;MPa&quot;<\/span>)<\/span><\/div>\n    <\/div>\n\n    <div class=\"nit-pg-highlight\"><strong>Your turn<\/strong><p>Add one calculation from the engineering field that interests you. Write the equation first, identify the inputs and units, create a function, test it with values you can calculate manually, then add it to the menu. Civil: concrete volume. Electrical: resistance. Mechanical: kinetic energy. Environmental: flow rate.<\/p><\/div>\n  <\/div>\n<\/section>\n\n<section class=\"nit-pg-section nit-pg-section--comparison\" id=\"debugging\" aria-labelledby=\"debugging-heading\">\n  <p class=\"nit-pg-eyebrow\">Checkpoint 1<\/p><h2 id=\"debugging-heading\">Before you move on, prove that you can build and debug<\/h2>\n  <div class=\"nit-pg-reasons\" aria-label=\"Beginner programming checkpoint\">\n    <div><span>A<\/span><h3>Explain the variables<\/h3><p>You can say what each important value represents and which unit it uses.<\/p><\/div>\n    <div><span>B<\/span><h3>Change the program<\/h3><p>You can add or modify a calculation without rebuilding everything from a tutorial.<\/p><\/div>\n    <div><span>C<\/span><h3>Find an error<\/h3><p>You can read an error message, inspect values and test a smaller part of the program.<\/p><\/div>\n    <div><span>D<\/span><h3>Check the engineering<\/h3><p>You compare the output with a manual calculation and confirm the formula and units.<\/p><\/div>\n  <\/div>\n<\/section>\n\n<section class=\"nit-pg-section\" id=\"numerical\" aria-labelledby=\"numerical-heading\">\n  <p class=\"nit-pg-eyebrow\">Step 3 \u00b7 numerical computing<\/p><h2 id=\"numerical-heading\">Move from one value to arrays, numerical methods and repeated calculations<\/h2>\n  <p>Engineering work quickly grows beyond one number at a time. NumPy provides multidimensional arrays together with numerical routines that include linear algebra and statistics, while SciPy adds algorithms for optimisation, integration, interpolation, differential equations and other scientific problems. <a href=\"#source-2\">[2]<\/a><a href=\"#source-3\">[3]<\/a><\/p>\n  <div class=\"nit-pg-definitions\" aria-label=\"NumPy and SciPy roles\">\n    <div class=\"nit-pg-definition\"><span class=\"nit-pg-definition__number\">NP<\/span><p class=\"nit-pg-definition__label\">NumPy<\/p><h3>Work efficiently with groups of numbers<\/h3><p>Start with arrays, indexing, arithmetic, averages, vector operations and basic matrix operations.<\/p><\/div>\n    <div class=\"nit-pg-definition nit-pg-definition--university\"><span class=\"nit-pg-definition__number\">SP<\/span><p class=\"nit-pg-definition__label\">SciPy<\/p><h3>Add deeper numerical methods<\/h3><p>Use it when engineering mathematics moves into optimisation, integration, interpolation, equations or modelling.<\/p><\/div>\n  <\/div>\n  <div class=\"nit-code-window\" aria-label=\"Repeated engineering calculations with a loop\">\n      <div class=\"nit-code-window__bar\"><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__dot\"><\/span><span class=\"nit-code-window__file\">loads.py<\/span><\/div>\n      <div class=\"nit-code-window__body\"><span class=\"nit-code-line\"><span class=\"nit-code-name\">loads<\/span> = [<span class=\"nit-code-number\">20000<\/span>, <span class=\"nit-code-number\">40000<\/span>, <span class=\"nit-code-number\">60000<\/span>, <span class=\"nit-code-number\">80000<\/span>]<\/span><span class=\"nit-code-line\"><span class=\"nit-code-name\">area<\/span> = <span class=\"nit-code-number\">2000<\/span><\/span><span class=\"nit-code-line\"><span class=\"nit-code-keyword\">for<\/span> load <span class=\"nit-code-keyword\">in<\/span> loads:<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-name\">stress<\/span> = load \/ area<\/span><span class=\"nit-code-line nit-code-line--indent\"><span class=\"nit-code-keyword\">print<\/span>(load, <span class=\"nit-code-string\">&quot;N \u2192&quot;<\/span>, stress, <span class=\"nit-code-string\">&quot;MPa&quot;<\/span>)<\/span><\/div>\n    <\/div>\n  <div class=\"nit-pg-highlight\"><strong>Checkpoint 2<\/strong><p>Take ten or more measurements, store them as a collection, calculate a useful engineering result and explain what the output means. At this stage, the code should help you work with many values instead of repeating the same calculation by hand.<\/p><\/div>\n<\/section>\n\n<section class=\"nit-pg-section nit-pg-section--comparison\" id=\"data\" aria-labelledby=\"data-heading\">\n  <p class=\"nit-pg-eyebrow\">Step 4 \u00b7 engineering data<\/p><h2 id=\"data-heading\">Learn to clean, analyse and plot measurement data<\/h2>\n  <p>pandas is designed for tabular information such as spreadsheets and database-style data, with support for sources including CSV, Excel, SQL, JSON and Parquet. <a href=\"#source-4\">[4]<\/a> Matplotlib provides plotting tools for turning numerical results into visualizations. <a href=\"#source-5\">[5]<\/a><\/p>\n  <div class=\"nit-cm-course-grid\" aria-label=\"Engineering data skills\">\n    <article class=\"nit-cm-course nit-cm-course--technical\"><div class=\"nit-cm-course__top\"><span class=\"nit-cm-course__icon\" aria-hidden=\"true\">CSV<\/span><h3>Read data<\/h3><\/div><p>Open a CSV or spreadsheet and inspect its rows, columns and data types.<\/p><small>pandas<\/small><\/article>\n    <article class=\"nit-cm-course nit-cm-course--workshop\"><div class=\"nit-cm-course__top\"><span class=\"nit-cm-course__icon\" aria-hidden=\"true\">CLN<\/span><h3>Clean data<\/h3><\/div><p>Identify missing values, inconsistent entries, duplicates and values that need conversion.<\/p><small>Data quality<\/small><\/article>\n    <article class=\"nit-cm-course nit-cm-course--business\"><div class=\"nit-cm-course__top\"><span class=\"nit-cm-course__icon\" aria-hidden=\"true\">\u03a3<\/span><h3>Summarise<\/h3><\/div><p>Calculate averages, extremes, counts, grouped results and new derived columns.<\/p><small>Analysis<\/small><\/article>\n    <article class=\"nit-cm-course nit-cm-course--creative\"><div class=\"nit-cm-course__top\"><span class=\"nit-cm-course__icon\" aria-hidden=\"true\">\u2197<\/span><h3>Plot results<\/h3><\/div><p>Create line, scatter, bar or histogram views with clear variables and units.<\/p><small>Matplotlib<\/small><\/article>\n    <article class=\"nit-cm-course nit-cm-course--community\"><div class=\"nit-cm-course__top\"><span class=\"nit-cm-course__icon\" aria-hidden=\"true\">NB<\/span><h3>Explain the work<\/h3><\/div><p>Use a Jupyter notebook to keep code, results, equations, notes and plots together. <a href=\"#source-6\">[6]<\/a><\/p><small>Jupyter<\/small><\/article>\n    <article class=\"nit-cm-course nit-cm-course--technical\"><div class=\"nit-cm-course__top\"><span class=\"nit-cm-course__icon\" aria-hidden=\"true\">GIT<\/span><h3>Track changes<\/h3><\/div><p>Use Git to record project history, commits and versions as your work becomes larger. <a href=\"#source-7\">[7]<\/a><\/p><small>Version control<\/small><\/article>\n  <\/div>\n  <div class=\"nit-pg-highlight\"><strong>Checkpoint 3<\/strong><p>Open a small dataset, answer three useful questions from it, create one correctly labelled graph and save your project with version history. You are now moving from beginner coding into practical engineering computation.<\/p><\/div>\n<\/section>\n\n<section class=\"nit-pg-section\" id=\"field-branch\" aria-labelledby=\"branch-heading\">\n  <p class=\"nit-pg-eyebrow\">Step 5 \u00b7 choose by engineering field<\/p><h2 id=\"branch-heading\">After the common core, let the engineering problem choose the next tool<\/h2>\n  <div class=\"nit-pg-table-wrap\" role=\"region\" tabindex=\"0\" aria-label=\"Programming skills by engineering direction\">\n    <table class=\"nit-pg-table\"><thead><tr><th scope=\"col\">Engineering direction<\/th><th scope=\"col\">Useful next skills<\/th><th scope=\"col\">Why they fit<\/th><\/tr><\/thead><tbody>\n      <tr><th scope=\"row\">Civil \/ structural<\/th><td>Python automation, NumPy\/SciPy, data handling<\/td><td>Repeated calculations, measurement data, numerical work and engineering-software workflows.<\/td><\/tr>\n      <tr><th scope=\"row\">Mechanical<\/th><td>Python, numerical methods, modelling tools<\/td><td>Force, motion, thermal analysis, simulation and experimental data.<\/td><\/tr>\n      <tr><th scope=\"row\">Electrical \/ electronics<\/th><td>Python \u2192 C\/C++ \u2192 microcontrollers<\/td><td>Move from computation into embedded hardware and device control.<\/td><\/tr>\n      <tr><th scope=\"row\">Mechatronics \/ robotics<\/th><td>Python + C\/C++ + embedded systems<\/td><td>Combine higher-level logic with sensor, actuator and controller programming.<\/td><\/tr>\n      <tr><th scope=\"row\">Data-heavy engineering<\/th><td>Python + pandas + SQL + visualization<\/td><td>Store, query, clean and explain large structured datasets.<\/td><\/tr>\n      <tr><th scope=\"row\">Control \/ modelling<\/th><td>Python scientific stack and\/or MATLAB<\/td><td>Numerical mathematics, modelling, data analysis and control workflows.<\/td><\/tr>\n      <tr><th scope=\"row\">IoT<\/th><td>Python\/MicroPython + C\/C++ + communications<\/td><td>Connect sensors, devices, networks and application logic.<\/td><\/tr>\n    <\/tbody><\/table>\n  <\/div><p class=\"nit-pg-table-note\">C\/C++ becomes especially relevant near hardware; Arduino&#8217;s language reference includes digital and analogue I\/O, mathematics, timing, interrupts and communication functions. <a href=\"#source-9\">[9]<\/a> SQL becomes useful when structured engineering records move into databases; SQLite is a self-contained SQL database engine stored in ordinary files. <a href=\"#source-8\">[8]<\/a><\/p>\n<\/section>\n\n<section class=\"nit-pg-section nit-pg-section--comparison\" aria-labelledby=\"matlab-heading\">\n  <p class=\"nit-pg-eyebrow\">Where MATLAB fits<\/p><h2 id=\"matlab-heading\">Learn MATLAB when your course or engineering workflow uses it<\/h2>\n  <p>MATLAB&#8217;s current documentation covers language fundamentals, arrays, data import and analysis, mathematics, graphics, scripts, functions and software-development workflows. <a href=\"#source-10\">[10]<\/a> The programming habits you have already built\u2014clear variables, arrays, functions, testing and interpretation\u2014transfer directly into that environment.<\/p>\n<\/section>\n\n<section class=\"nit-pg-section\" id=\"twelve-weeks\" aria-labelledby=\"weeks-heading\">\n  <p class=\"nit-pg-eyebrow\">A practical starting timetable<\/p><h2 id=\"weeks-heading\">A 12-week beginner plan<\/h2>\n  <div class=\"nit-pg-table-wrap\" role=\"region\" tabindex=\"0\" aria-label=\"Twelve week engineering programming roadmap\"><table class=\"nit-pg-table\"><thead><tr><th scope=\"col\">Week<\/th><th scope=\"col\">Focus<\/th><th scope=\"col\">Target<\/th><\/tr><\/thead><tbody>\n    <tr><th scope=\"row\">1<\/th><td>Variables, calculations, output<\/td><td>Write formula-based programs.<\/td><\/tr>\n    <tr><th scope=\"row\">2<\/th><td>Input + conditions<\/td><td>Build interactive calculations.<\/td><\/tr>\n    <tr><th scope=\"row\">3<\/th><td>Loops + lists<\/td><td>Process several values.<\/td><\/tr>\n    <tr><th scope=\"row\">4<\/th><td>Functions<\/td><td>Organise calculations into reusable tasks.<\/td><\/tr>\n    <tr><th scope=\"row\">5<\/th><td>Engineering Calculator<\/td><td>Combine the first major concepts.<\/td><\/tr>\n    <tr><th scope=\"row\">6<\/th><td>Debugging + validation<\/td><td>Improve inputs and verify results.<\/td><\/tr>\n    <tr><th scope=\"row\">7<\/th><td>NumPy<\/td><td>Work with numerical arrays.<\/td><\/tr>\n    <tr><th scope=\"row\">8<\/th><td>pandas<\/td><td>Read and analyse tabular data.<\/td><\/tr>\n    <tr><th scope=\"row\">9<\/th><td>Matplotlib<\/td><td>Produce an engineering graph.<\/td><\/tr>\n    <tr><th scope=\"row\">10<\/th><td>Jupyter<\/td><td>Document a complete calculation.<\/td><\/tr>\n    <tr><th scope=\"row\">11<\/th><td>Git<\/td><td>Track project changes.<\/td><\/tr>\n    <tr><th scope=\"row\">12<\/th><td>Mini-project<\/td><td>Solve one engineering problem independently.<\/td><\/tr>\n  <\/tbody><\/table><\/div><p class=\"nit-pg-table-note\">Use the sequence as a guide. Spend extra practice time on any stage that is not yet comfortable.<\/p>\n<\/section>\n\n<section class=\"nit-pg-section\" aria-labelledby=\"progress-heading\">\n  <p class=\"nit-pg-eyebrow\">How to measure progress<\/p><h2 id=\"progress-heading\">Judge the skill by what you can build and explain<\/h2>\n  <div class=\"nit-deg-band-grid\" aria-label=\"Programming progress checks\">\n    <article class=\"nit-deg-band\"><div class=\"nit-deg-band__head\"><span>Technical ability<\/span><h3>Can you solve the problem?<\/h3><\/div><ul><li>Identify inputs, outputs and units.<\/li><li>Choose the correct equation or procedure.<\/li><li>Write the calculation in code.<\/li><li>Test it against a known result.<\/li><li>Correct mistakes methodically.<\/li><\/ul><\/article>\n    <article class=\"nit-deg-band nit-deg-band--competitive\"><div class=\"nit-deg-band__head\"><span>Independent ability<\/span><h3>Can you improve the solution?<\/h3><\/div><ul><li>Rename unclear variables.<\/li><li>Turn repeated logic into functions.<\/li><li>Add validation.<\/li><li>Process more than one value.<\/li><li>Explain your choices to another learner.<\/li><\/ul><\/article>\n  <\/div>\n  <p>A good engineering programmer is not measured by the number of languages they can name. What matters is whether they can take a technical problem, turn it into working code, check the result and explain how the solution works.<\/p>\n<\/section>\n\n<section class=\"nit-pg-section\" id=\"faqs\" aria-labelledby=\"faqs-heading\">\n  <p class=\"nit-pg-eyebrow\">Quick questions<\/p><h2 id=\"faqs-heading\">Programming skills for engineering students: FAQs<\/h2>\n  <div class=\"nit-pg-faq\">\n    <details><summary>Which programming language should engineering students learn first?<\/summary><div><p>For this beginner roadmap, start with Python. It supports a clear progression from basic programming into numerical computing, data analysis, plotting and automation. <a href=\"#source-1\">[1]<\/a><a href=\"#source-2\">[2]<\/a><a href=\"#source-3\">[3]<\/a><\/p><\/div><\/details>\n    <details><summary>Should an engineering student learn Python or C++ first?<\/summary><div><p>Start with Python for general engineering computation. Move into C\/C++ early when your work involves microcontrollers, embedded electronics, robotics or lower-level hardware control. Arduino&#8217;s official reference illustrates the kinds of hardware-facing functions used in that branch. <a href=\"#source-9\">[9]<\/a><\/p><\/div><\/details>\n    <details><summary>Can I start programming before studying engineering?<\/summary><div><p>Yes. Start with mathematics you already understand\u2014area, volume, speed, density, power, percentages or unit conversion\u2014then turn each formula into a small program. The technical complexity can grow alongside your engineering studies.<\/p><\/div><\/details>\n  <\/div>\n<\/section>\n\n<section class=\"nit-pg-final\" aria-labelledby=\"final-heading\"><p class=\"nit-pg-eyebrow\">The practical rule<\/p><h2 id=\"final-heading\">Learn enough programming to solve the next engineering problem well<\/h2><p>Begin with logic and Python. Build a real application early. Add numerical computing, data, visualization, notebooks and version control as your projects demand them. Then specialise into the language or tool that fits your engineering field.<\/p><\/section>\n\n<section class=\"nit-pg-section\" aria-labelledby=\"related-heading\"><p class=\"nit-pg-eyebrow\">Continue learning<\/p><h2 id=\"related-heading\">Useful Newton Institute of Technology pathways<\/h2><div class=\"nit-lv-related\">\n  <a href=\"https:\/\/niteducation.com\/courses\/ict\"><span>Beginner programming<\/span><strong>Python Programming at NIT<\/strong><\/a>\n  <a href=\"https:\/\/niteducation.com\/resources\/full-stack-software-development-course\/\"><span>Build complete applications<\/span><strong>Full-Stack Software Development<\/strong><\/a>\n  <a href=\"https:\/\/niteducation.com\/resources\/data-science-course-in-kenya\/\"><span>Work with data<\/span><strong>Data Science &amp; Analytics<\/strong><\/a>\n<\/div><\/section>\n\n<section class=\"nit-pg-enrol\" aria-labelledby=\"enrol-heading\">\n  <div class=\"nit-pg-enrol__copy\"><p class=\"nit-pg-eyebrow\">Start with practical programming<\/p><h2 id=\"enrol-heading\">Register for Programming Training at Newton Institute of Technology<\/h2><p>Newton Institute of Technology&#8217;s ICT catalogue includes a four-month part-time Python Programming course designed for learners starting from the foundations and building practical applications. Learners who want to progress into complete software systems can continue into Full-Stack Software Development. <a href=\"#source-11\">[11]<\/a><\/p><\/div>\n  <div class=\"nit-pg-enrol__details\"><p><span>Starting route<\/span><strong>Python Programming<\/strong><\/p><p><span>Current catalogue duration<\/span><strong>4 months \u00b7 part-time<\/strong><\/p><p><span>Admissions<\/span><strong>Newton Institute of Technology<\/strong><\/p><\/div>\n  <div class=\"nit-pg-enrol__actions\"><a class=\"nit-pg-button nit-pg-button--gold\" href=\"https:\/\/niteducation.com\/admissions\/\">Register \/ admissions<\/a><a class=\"nit-pg-button nit-pg-button--outline\" href=\"https:\/\/niteducation.com\/courses\/ict\">View ICT programmes<\/a><\/div>\n<\/section>\n\n<div class=\"nit-pg-sources\" aria-labelledby=\"sources-heading\"><h2 id=\"sources-heading\">Technical references<\/h2><ol>\n  <li id=\"source-1\"><strong>Python Software Foundation.<\/strong> <cite>The Python Tutorial.<\/cite> Covers numbers, lists, control flow, functions, files, errors and core Python concepts. <a href=\"https:\/\/docs.python.org\/3\/tutorial\/\" target=\"_blank\" rel=\"noopener\">Python documentation<\/a>.<\/li>\n  <li id=\"source-2\"><strong>NumPy Developers.<\/strong> <cite>NumPy Documentation.<\/cite> Reference for multidimensional arrays, numerical operations, statistics and linear algebra. <a href=\"https:\/\/numpy.org\/doc\/stable\/\" target=\"_blank\" rel=\"noopener\">NumPy documentation<\/a>.<\/li>\n  <li id=\"source-3\"><strong>SciPy Community.<\/strong> <cite>SciPy.<\/cite> Scientific-computing algorithms for optimisation, integration, interpolation, differential equations, statistics and related numerical work. <a href=\"https:\/\/scipy.org\/\" target=\"_blank\" rel=\"noopener\">SciPy<\/a>.<\/li>\n  <li id=\"source-4\"><strong>pandas Development Team.<\/strong> <cite>Getting Started.<\/cite> Covers tabular data and integration with CSV, Excel, SQL, JSON and Parquet. <a href=\"https:\/\/pandas.pydata.org\/docs\/getting_started\/\" target=\"_blank\" rel=\"noopener\">pandas documentation<\/a>.<\/li>\n  <li id=\"source-5\"><strong>Matplotlib Development Team.<\/strong> <cite>Matplotlib Documentation.<\/cite> Official plotting and visualization documentation. <a href=\"https:\/\/matplotlib.org\/stable\/\" target=\"_blank\" rel=\"noopener\">Matplotlib documentation<\/a>.<\/li>\n  <li id=\"source-6\"><strong>Project Jupyter.<\/strong> <cite>Project Jupyter Documentation.<\/cite> Official documentation for computational notebooks combining code, explanatory text and visual outputs. <a href=\"https:\/\/docs.jupyter.org\/en\/latest\/\" target=\"_blank\" rel=\"noopener\">Jupyter documentation<\/a>.<\/li>\n  <li id=\"source-7\"><strong>Git Project.<\/strong> <cite>Git Documentation.<\/cite> Official reference for repositories, changes, commits, history and version-control workflows. <a href=\"https:\/\/git-scm.com\/doc\" target=\"_blank\" rel=\"noopener\">Git documentation<\/a>.<\/li>\n  <li id=\"source-8\"><strong>SQLite Project.<\/strong> <cite>About SQLite.<\/cite> Describes SQLite as a self-contained SQL database engine whose complete database is stored in an ordinary file. <a href=\"https:\/\/www.sqlite.org\/about.html\" target=\"_blank\" rel=\"noopener\">SQLite<\/a>.<\/li>\n  <li id=\"source-9\"><strong>Arduino.<\/strong> <cite>Language Reference.<\/cite> Official reference covering variables, digital and analogue I\/O, mathematical functions, timing, interrupts and communication. <a href=\"https:\/\/docs.arduino.cc\/language-reference\/\" target=\"_blank\" rel=\"noopener\">Arduino documentation<\/a>.<\/li>\n  <li id=\"source-10\"><strong>MathWorks.<\/strong> <cite>MATLAB Documentation.<\/cite> Covers language fundamentals, data analysis, mathematics, graphics, scripts, functions and software development. <a href=\"https:\/\/www.mathworks.com\/help\/matlab\/index.html\" target=\"_blank\" rel=\"noopener\">MATLAB documentation<\/a>.<\/li>\n  <li id=\"source-11\"><strong>Newton Institute of Technology.<\/strong> <cite>School of ICT &amp; Computer Courses.<\/cite> Current NIT catalogue listing Python Programming as four months part-time and Full-Stack Software Development as eight months full-time. <a href=\"https:\/\/niteducation.com\/courses\/ict\">niteducation.com<\/a>.<\/li>\n<\/ol><p><strong>Prepared by:<\/strong> Newton Institute of Technology Editorial Team \u00b7 <strong>Institutional \/ Technical review:<\/strong> Engineer Simon Barongo \u00b7 <strong>Last reviewed:<\/strong> 22 October 2026.<\/p><\/div>\n<\/div><\/article>\n","protected":false},"excerpt":{"rendered":"<p>Engineering programming roadmap \u00b7 beginner to project Programming Skills Engineering Students Should Learn First Start with problem-solving and Python, build a working Engineering Calculator, then add numerical computing, data, graphs, version control and the tools your engineering field needs. Start with Python Build a real project Then specialise by field See the learning order Build [&hellip;]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[30],"tags":[702,701,703],"class_list":["post-3638","post","type-post","status-publish","format-standard","hentry","category-ict","tag-programming-for-engineering-students","tag-programming-skills-for-engineering-students","tag-python-for-engineering-students"],"_links":{"self":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts\/3638","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/comments?post=3638"}],"version-history":[{"count":1,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts\/3638\/revisions"}],"predecessor-version":[{"id":3639,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/posts\/3638\/revisions\/3639"}],"wp:attachment":[{"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/media?parent=3638"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/categories?post=3638"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/niteducation.com\/resources\/wp-json\/wp\/v2\/tags?post=3638"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}