🌟 Day 5 — Learning JavaScript 👋 Hi everyone! Today’s learning was amazing 🤩 -> I worked on DOM Manipulation and JavaScript Timers (setInterval & clearInterval). -> To practice these concepts, I built a Bomb Blast Simulation Task , and the entire UI was generated using JavaScript only — no manual HTML tags. 🔹 1. DOM (Document Object Model) Methods: -> DOM allows JavaScript to interact with a webpage dynamically — create elements, modify them, remove them, and handle events. -> Here are the DOM methods I learned and used today: ✅ Selecting / Accessing Elements -> document.getElementById() -> document.getElementsByClassName() -> document.getElementsByTagName() -> document.querySelector() -> document.querySelectorAll() ✅ Creating Elements -> document.createElement() ✅ Inserting Elements into DOM -> append() → add at the end -> prepend() → add at the beginning -> appendChild() → insert a node i-> nsertBefore() → insert before another element -> insertAdjacentHTML(position, HTML) → inserts HTML without removing existing content ✅ Modifying Elements -> .innerText → change text inside an element -> .innerHTML → change HTML content -> .textContent → similar to innerText but shows hidden text too -> .style.property → change CSS from JS (example: element.style.display = "none") -> .setAttribute(name, value) → set attributes (id, class, src) -> .getAttribute(name) → read attribute value -> .classList.add() → add class -> .classList.remove() → remove class -> .classList.toggle() → add/remove class automatically ✅ Removing Elements -> .remove() Using these DOM methods, I created: -> Main container -> Sub-container -> Heading text -> Timer text -> Start & Stop buttons -> Bomb and blast images Everything was built dynamically through JavaScript! 🔹 2. setInterval() & clearInterval(): ⏱ setInterval() → executes code repeatedly at a fixed time ⛔ clearInterval() → stops the interval -> I used this to create a countdown timer. When the timer reached 0 : -> Bomb image hides -> Blast image shows -> Timer stops automatically 💣 Bomb Blast Task (JS Only) ✔ JavaScript dynamically created all HTML content ✔ Timer starts on the "Start" button ✔ Bomb explodes using image toggle ✔ "Stop" button stops the interval immediately This task helped me understand how real-time UI updates work in JavaScript. 🚀 What I improved today -> DOM Manipulation (create, insert, update, delete elements) -> Dynamic UI generation using JavaScript -> Event handling (button click actions) -> Timer control using setInterval() & clearInterval() 🔗 Source Code & Live Demo Links 📂 GitHub Repo: https://lnkd.in/gtxXv9sJ 🌐 Live Demo: https://lnkd.in/gcGjqpKJ #100DaysOfCode #Day5 #JavaScript #FrontendDevelopment #WebDevelopment #LearningInPublic #DOM #CodingJourney #SetInterval #ClearInterval #DynamicUI #Developer #ProjectBuilding
More Relevant Posts
-
Hi Everyone, Day [18, 19 & 20]: - Daily Web Development Learning With @frontlinesedutech || AI Powered Web Development Course. 🚀 JavaScript: I’ve officially kicked off my JavaScript journey — and it’s been an exciting ride so far! Here’s a quick breakdown of what I’ve explored: 🧠 What is JavaScript? JavaScript is the programming language that brings websites to life — enabling interactivity, animations, and dynamic content. 🧠 ECMAScript vs JavaScript — What’s the Relationship? --> ECMAScript is the official specification (or standard) for scripting languages maintained by ECMA International. -->JavaScript is the most popular implementation of ECMAScript — meaning it follows the rules and guidelines defined by ECMAScript. 🔄 Timeline Insight --> JavaScript was created first (in 1995), and then ECMAScript was introduced in 1997 to standardize the language across browsers. --> So rather than ECMAScript being "taken to JavaScript," it's more accurate to say: --> JavaScript was standardized as ECMAScript to ensure consistency and compatibility. --> Think of ECMAScript as the rulebook, and JavaScript as the player that follows those rules. 🌐 Running JavaScript in the Browser I learned how to write and execute JS directly in the browser using the console and script tags — no setup needed! 🔑 Variables and Keywords Understanding how to store data using let, const, and var, and the rules around naming and scope. 📋 Logging with JavaScript Explored several ways to interact with users and debug code: --> console.log() – For general messages --> console.warn() – For warnings --> alert() – Pops up a message box with an OK button --> prompt() – Asks the user for input --> confirm() – Asks the user to confirm an action (OK/Cancel) 🧵 Working with Strings Manipulating text with methods like .length, .toUpperCase(), and string concatenation — essential for dynamic content. 🔢 JavaScript Data Types Explored the core types: --> Primitive: String, Number, Boolean, Null, Undefined, BigInt, Symbol --> Non-Primitive: Object (includes arrays, functions, etc.) ⚖️ Difference Between var and const: --> var is function-scoped, allows re-declaration and reassignment. -->const is block-scoped, and once assigned, its value can’t be changed. 💡 Every concept is helping me build a stronger foundation for interactive, responsive websites. Can’t wait to dive into DOM manipulation and functions next! Excited to keep building and styling with purpose! I'm grateful for being guided by my trainer #SrujanaVattamawar Proud to be learning with Frontlines Edutech, where we turn curiosity into capability and learners into professionals. #WebDevelopment #CSS #FrontendDevelopment #CodingJourney #TechSkills #frontlinesedutech #flm #frontlinesmedia #VibeCoding #LearnToCode #LinkedInLearning #JavaScript
-
Hey LinkedIn Family...👋 🌐My JavaScript Learning Journey — Understanding the DOM (Document Object Model) Today, I explored one of the most powerful and interesting concepts in JavaScript — DOM (Document Object Model). It’s the backbone that connects JavaScript with the webpage, allowing dynamic and interactive behavior!🚀 🧩 What is DOM in JavaScript? DOM stands for Document Object Model. It represents an HTML document as a tree of objects, where each element (like <p>, <div>, <h1>) becomes a node that JavaScript can access and manipulate. Through DOM, we can: 🔹 Change content dynamically 🔹 Add or remove elements 🔹 Handle user interactions 🔹 Modify styles in real time ⚙️ How DOM Adds Interactivity to Web Pages DOM enables JavaScript to “talk” to HTML and CSS. For example — when a user clicks a button, JavaScript can update the text, show alerts, or even change page structure instantly! ✅Example: <!DOCTYPE html> <html> <body> <h2 id="title">Hello World!</h2> <button onclick="changeText()">Click Me</button> <script> function changeText() { document.getElementById("title").innerHTML = "Welcome to JavaScript DOM!"; } </script> </body> </html> 💡Output: Before click → “Hello World!” After click → “Welcome to JavaScript DOM!” 🌳 Understanding the DOM Tree: Every HTML document forms a hierarchical tree — known as the DOM Tree. ✅Example structure: Document └── html ├── head └── body ├── h2 └── button Each node (like html, body, h2, button) can be accessed and modified using JavaScript DOM methods. ✨Common DOM Methods 1️⃣ getElementById(): Finds an element by its unique ID. 2️⃣ getElementsByClassName(): Selects all elements with a specific class name. 3️⃣ querySelector() & querySelectorAll(): Powerful methods to select elements using CSS selectors. 4️⃣ createElement() & appendChild(): Used to create and add new elements dynamically. 5️⃣ removeChild(): Removes a specific child element. 💭 My Learning Takeaway DOM makes JavaScript alive and interactive! It’s fascinating how we can modify an entire webpage dynamically through simple scripts. 🚀 #JavaScript #WebDevelopment #Frontend #LearningJourney #DOM #Programming #100DaysOfCode #WebDev #CodeNewbie #TechLearning #JavaScript #DOM #WebDevelopment #Coding #Programming #FrontendDevelopment
-
🌱 Day 22 of My JavaScript Learning Journey — Arrays & Loops 🚀with Frontlines EduTech (FLM) Today I explored JavaScript Arrays and Loops, two fundamental yet powerful concepts that form the backbone of most programs. 🧩 Arrays — Understanding Soft & Hard Copies Arrays are used to store multiple values in a single variable. Here’s what I practiced today 👇 🔹 Soft Copy (Reference Copy) let trees = ['neem tree', 'oak tree', 'mango tree', 'pine tree']; let softCopy = trees; trees.pop(); console.log(trees); console.log(softCopy); ➡ Both variables point to the same array — removing an element from one affects the other. 🔹 Hard Copy (Using Spread Operator) let fruits = ['guava', 'banana', 'apple', 'grapes']; let copy = [...fruits]; // spread operator fruits.pop(); console.log(fruits); console.log(copy); ➡ The spread operator ... helps create a separate copy of the array. 🔹 Merging Arrays let popularCities = ['mumbai', 'chennai', 'hyd', 'vizag']; let favCities = ['pune', 'bangalore', 'delhi']; console.log(popularCities.concat(favCities)); 🔹 Finding Array Length let cities = ['mumbai', 'chennai', 'hyd', 'vizag']; let length = cities.length; console.log(length); 🔁 Loops — Automating Repetition Loops allow us to execute a set of instructions repeatedly until a condition is met. 🧠 While Loop Example Flow: Condition → True → Execute Block → Check Again → End ✅ Example 1: Printing Numbers from 1 to 5 let i = 1; while (i <= 5) { console.log(i); i++; } ✅ Example 2: Sum of Numbers from 1 to 5 let sum = 0; let j = 1; while (j <= 5) { sum = sum + j; j++; } console.log(sum); ✅ Example 3: Countdown let countdown = []; let k = 5; while (k >= 1) { countdown.push(k); k--; } console.log(countdown); 💡 Key Takeaways: Arrays can be copied by reference or by value. The spread operator (...) is an easy way to create a clone. Loops help automate repetitive tasks effectively. Every small concept I learn builds my foundation stronger 💪 #JavaScript #WebDevelopment #flm #frontlinesmedia A special thanks to Srujana Vattamwar Krishna Mantravadi
-
-
Types of Errors in JavaScript: * JavaScript is a powerful language, but even a small mistake can lead to unexpected errors. * Understanding these errors helps us debug faster and write cleaner code. Here are the 5 main types of errors in JavaScript: 1. Syntax Error Definition: * Occurs when the code is written incorrectly and JavaScript cannot understand it. * It happens before execution (during parsing). Example: console.log("Hello World" // Missing parenthesis Error Message: * Uncaught SyntaxError: missing ) after argument list Explanation: * JS expected a ) but didn’t find one. These are simple typos that break code instantly. 2. Reference Error Definition: * Occurs when trying to access a variable that doesn’t exist or is out of scope. Example: console.log(name); // name not defined Error Message: * Uncaught ReferenceError: name is not defined Explanation: * This means JS cannot find the variable in memory. * Always declare variables before using them! 3. Type Error Definition: * Occurs when a value is not of the expected type, or a property/method doesn’t exist on that type. Example: let num = 10; num.toUpperCase(); // Not valid on numbers Error Message: * Uncaught TypeError: num.toUpperCase is not a function Explanation: * Only strings can use .toUpperCase(). * TypeErrors often happen due to wrong variable usage. 4. Range Error Definition: Occurs when a number or value is outside its allowed range. Example: let arr = new Array(-5); // Negative length not allowed Error Message: * Uncaught RangeError: Invalid array length Explanation: * Array sizes must be non-negative. * You’ll see this error when loops, recursion, or array sizes go beyond limits. 5. URI Error Definition: * Occurs when using encodeURI() or decodeURI() incorrectly with invalid characters. Example: decodeURI("%"); // Invalid escape sequence Error Message: * Uncaught URIError: URI malformed Explanation: * URI (Uniform Resource Identifier) functions expect valid encoded URLs. * Always validate URLs before decoding! Conclusion * Errors are not your enemies—they’re your best teachers. * By understanding these core JavaScript errors, you’ll spend less time debugging and more time building awesome things. KGiSL MicroCollege #JavaScript #WebDevelopment #FrontendDevelopment #Programming #Coding #LearnToCode #JS #ErrorHandling #CodeNewbie #SoftwareEngineering #WebDesign #Developers #CodeTips #ProgrammingLife #CleanCode #WebApp #DeveloperCommunity #CodeDaily #BugFixing #JSDeveloper #TechCommunity #100DaysOfCode #WomenInTech #FullStackDeveloper #FrontendDeveloper #SoftwareDeveloper #CodingJourney #TechLearning #CodeBetter #TechEducation
-
-
Understanding JavaScript Functions: If you’re learning JavaScript, you’ve probably heard the word function hundreds of times. But did you know there are different types of functions — and each one works a little differently? Let’s break it down in simple words: 1) Regular Function (Function Declaration) This is the most common type of function — declared using the function keyword. You can call it before or after defining it. example: function greet() { console.log("Hello!"); } greet(); 2) Function Expression A function can be stored inside a variable. You can only call it after it’s defined. example: const greet = function() { console.log("Hello!"); }; greet(); 3) Arrow Function A shorter way to write functions — commonly used in modern JavaScript. Great for small tasks and callbacks. example: const greet = () => console.log("Hello!"); greet(); 4) Higher-Order Function These are functions that take another function as an argument or return a function. Very common in array methods like map, filter, and reduce. example: function sayHello() { console.log("Hello!"); } function greet(fn) { fn(); // calling the function passed } greet(sayHello); 5) Closure Function A closure happens when an inner function remembers variables from its outer function, even after the outer function finishes running. example: function outer() { let count = 0; return function inner() { count++; console.log(count); }; } const counter = outer(); counter(); // 1 counter(); // 2
-
🧩 Understanding “Palindrome Number” in JavaScript — Beginner Friendly 💡 When I first learned about palindrome numbers (like 121 or 1223221), I got confused by one simple question: 👉 “Why do we need another variable like original to store the number?” Let’s break it down 👇 🔍1️⃣What happens inside the loop? This part confuses many learners at first. When you use the same variable inside the loop (like x or n), you keep changing it in every iteration: let x = 121; let rev = 0; while (x > 0) { let rem = x % 10; rev = 10 * rev + rem; x = Math.floor(x / 10); } console.log("x =", x); // 👉 0 console.log("rev =", rev); // 👉 121 🧠 Inside the loop, you are dividing x each time → x = 0 at the end. So when the loop ends, you lose the original number. That’s why we store it first 👇 let original = x; Then at the end: return original === rev; ✅ This way, you still have the original value to compare. 🧩 2️⃣ When you don’t need original If you pass the number as a parameter, JavaScript creates a copy of it — so the outer value stays safe even if the inner one changes. let n = 121; function palindrome(num) { let rev = 0; while (num > 0) { let rem = num % 10; rev = 10 * rev + rem; num = Math.floor(num / 10); } return rev; } let result = palindrome(n); console.log("n =", n); // 👉 still 121 console.log("result =", result); // 👉 121 ✅ Here you don’t need original because: The function gets a copy of n (numbers are passed by value). Inside the function, only that copy (num) becomes 0. The outer n never changes — it still holds the original number. 🧠 So you can safely compare like: if (n === result) console.log("Palindrome"); 🔍 3️⃣ Why x is 0 even outside the loop That’s a very smart question 👏 — and it shows real understanding of JavaScript. Because in JavaScript, variables declared with let inside the same function share the same function scope — not separate scopes for loops. That means: You used the same variable x inside and outside the loop. Each time in the loop you did x = Math.floor(x / 10). When the loop finishes, x keeps its last modified value → 0. 💡 In short: while doesn’t create a new scope — so x keeps changing even outside the loop. ✅ If you want to keep the original safe → copy it before modifying: let original = x; ✨I shared this because I know how small confusions like these can stop learning flow. Small things like these make a big difference when learning JavaScript logic. If this helped you understand the “original” confusion, drop a 💬 or ❤️ to help other learners too! #JavaScript #CodingJourney #FrontendDevelopment #DeveloperTips #LearnByDoing
-
Studying the syntax of HTML, CSS, and JavaScript involves a combination of theoretical understanding and practical application. 1. Understand the Fundamentals: HTML (HyperText Markup Language): Focus on elements, tags (opening and closing), attributes, and their nesting structure. Understand the purpose of common tags like <div>, <p>, <h1>, <a>, <img>, and form elements. CSS (Cascading Style Sheets): Learn about selectors (element, class, ID), properties, values, and the declaration block structure. Understand how to apply styles using inline, internal, and external CSS. Explore concepts like the box model, flexbox, and grid for layout. JavaScript: Grasp fundamental programming concepts such as variables, data types, operators, conditional statements (if/else), loops (for, while), functions, and objects. Learn how to interact with HTML elements (DOM manipulation) and handle events. 2. Utilize Learning Resources: Official Documentation (MDN Web Docs): These resources provide comprehensive and accurate information on HTML, CSS, and JavaScript syntax and usage. Interactive Platforms: Websites like Codecademy, freeCodeCamp, and W3Schools offer structured courses and interactive exercises to practice syntax. Video Tutorials: Platforms like YouTube host numerous tutorials explaining concepts and demonstrating code examples. Books and Online Articles: Explore various resources that delve into specific aspects of each language. 3. Practice Consistently: Code Along with Tutorials: Actively type out the code examples provided in tutorials to reinforce syntax and build muscle memory. Build Small Projects: Start with simple projects to apply learned concepts. For example, create a basic webpage with styled elements and add interactive features using JavaScript. Experiment and Debug: Modify existing code, try different approaches, and learn to identify and fix syntax errors using browser developer tools. Use Online Code Editors: Platforms like CodePen or JSFiddle allow for quick experimentation with HTML, CSS, and JavaScript without setting up a local development environment. 4. Review and Reinforce: Create Cheat Sheets: Summarize commonly used tags, properties, and JavaScript syntax for quick reference. Regularly Review Code: Revisit your own code and examples from tutorials to solidify understanding. Explain Concepts to Others: Teaching or explaining concepts to someone else can highlight areas where your understanding needs improvement. 5. Focus on Understanding, Not Just Memorization: While memorizing syntax is part of the process, prioritize understanding the underlying logic and purpose of each element, property, or JavaScript construct. This deeper understanding will enable you to apply the syntax effectively in various scenarios.
-
💻 Learning Update: JavaScript DOM — Calculator Application Today, I learned how to build a Calculator Application using JavaScript and the DOM (Document Object Model) under the guidance of Manoj Kumar Reddy Parrapalli at 10000 Coders. This session helped me understand how to use DOM manipulation, event handling, and logical operations to make a fully functional calculator. 🧠 Key Concepts and Their Definitions 🔹 1. JavaScript JavaScript is a high-level programming language used to make web pages interactive and dynamic. It allows developers to add real-time functionality such as user input handling, calculations, and UI updates. 🔹 2. DOM (Document Object Model) The DOM represents the structure of an HTML document as a tree of objects. It enables developers to access and manipulate HTML elements (like buttons, inputs, and text) using JavaScript. 🔹 3. DOM Manipulation DOM Manipulation involves changing the content, style, or structure of a webpage dynamically using JavaScript methods like: document.getElementById() document.querySelector() document.createElement() In the calculator project, DOM manipulation is used to display numbers and results dynamically on the screen. 🔹 4. Event Handling Event handling allows JavaScript to respond to user actions such as clicks or key presses. For example, when a user clicks a button (+, -, *, /, or =), JavaScript executes a function to perform that operation. button.addEventListener("click", calculate); 🔹 5. Arithmetic Operations Arithmetic operators (+, -, *, /, %) are used to perform mathematical calculations based on user input. In the calculator, these operators are linked to buttons and executed when the user performs calculations. 🔹 6. Display Update The calculator’s display screen updates dynamically using DOM properties like innerText or value. Example: document.getElementById("result").value = currentValue; 🔹 7. Clear and Reset Functions The Clear (C) or Reset button helps to remove all current inputs and start a new calculation. This function clears both the display and the stored values in JavaScript. 💡 Key Takeaways Learned how to build interactive web applications using DOM. Understood event handling and user input management. Strengthened logic for basic arithmetic and state handling in JavaScript. ✨ Conclusion Creating a Calculator Application using JavaScript and DOM helped me enhance my skills in frontend interactivity, logical thinking, and event-driven programming — an essential step toward becoming a strong frontend developer. #JavaScript #DOM #FrontendDevelopment #10000Coders #LearningJourney #ManojKumarReddyParrapalli #CalculatorApp #WebDevelopment #CodeLearning #EventHandling 10000 Coders Manoj Kumar Reddy Parlapalli
-
🔄 Callback Functions in JavaScript — Simplified In JavaScript, functions are first-class citizens, which means we can pass them as arguments to other functions, return them, or store them in variables. A callback function is simply a function passed as an argument to another function and executed later, often after some operation completes. 🧠 Why We Use Callbacks Callbacks are especially useful when dealing with asynchronous operations — such as fetching data from an API, reading files, or handling events — where we want code to run after a certain task completes. 💡 Example function greetUser(name, callback) { console.log(`Hello, ${name}!`); callback(); } function showMessage() { console.log("Welcome to JavaScript callbacks!"); } // Passing showMessage as a callback greetUser("Abdul", showMessage); Output : Hello, Abdul! Welcome to JavaScript callbacks! Here, showMessage is a callback function that runs aftergreetUser() finishes its main task. ⚙️ Real-World Example (Asynchronous) console.log("Start"); setTimeout(() => { console.log("Callback executed after 2 seconds"); }, 2000); console.log("End"); Output : Start End Callback executed after 2 seconds 👉 setTimeout() takes a callback that runs after 2 seconds — demonstrating asynchronous behavior. 🚀 In Short ✅ A callback function is : • A function passed as an argument to another function • Executed after the main function finishes • Essential for handling asynchronous tasks 💬 Final Thought Callback functions are the foundation of asynchronous programming in JavaScript. Modern approaches like Promises and async/await were built on top of this very concept.
-
-
🚀 The Hidden Power of Set and Reduce in JavaScript When I first started writing JavaScript, my main goal was just to make things work. But over time, I realized that true skill in programming isn’t about just making it work — it’s about making it faster, cleaner, and smarter. Recently, I discovered a few simple yet game-changing techniques that made my code far more efficient. ⚡ 1️⃣ From Array → Set: A Smarter Way to Handle Lookups In JavaScript, when we use forEach or includes() to check values inside an array, the code scans through each element one by one — which means a time complexity of O(n²) in some cases. Then I learned something powerful — using Set instead of Array can instantly reduce that to O(1) for lookups! const nums = [1, 2, 3, 4, 5, 2, 3]; const numSet = new Set(nums); console.log(numSet.has(3)); // true 👉 The .has() method checks for existence almost instantly because Sets are optimized with hashing under the hood. 🧠 2️⃣ includes() vs has() — Know the Difference Method Used In Complexity Example includes() Array O(n) arr.includes(5) has() Set / Map O(1) mySet.has(5) 💡 Lesson: Choosing the right data structure can drastically improve your code’s performance. 🧮 3️⃣ The Power of reduce(): Beyond Just Summing Values Like most developers, I used to think reduce() was only useful for summing numbers. But the truth is — it’s one of the most versatile and powerful tools in JavaScript. You can use reduce() to group data, count occurrences, find extremes, and even transform complex data — all in a single line. 🌟 Some Powerful reduce() Examples 🔹 Group Products by Category const grouped = products.reduce((acc, item) => { acc[item.category] = acc[item.category] || []; acc[item.category].push(item); return acc; }, {}); 🔹 Find the Highest Priced Product const highest = products.reduce((acc, item) => acc.price > item.price ? acc : item ); 🔹 Calculate Brand-wise Total Sales const brandWise = products.reduce((acc, item) => { acc[item.brand] = (acc[item.brand] || 0) + item.price * item.quantity; return acc; }, {}); 👉 With reduce(), I can now replace multiple loops with a single elegant function. Less code, less complexity, more power. ⚡ 🧩 4️⃣ The Mindset Shift The biggest lesson I’ve learned is this: “Programming isn’t just about making things work — it’s about making them work efficiently.” Now, whenever I write code, I ask myself: ✅ Can I reduce the time complexity? ✅ Am I using the right data structure? ✅ Can this be done in a cleaner, smarter way? That mindset alone changes everything. 🏁 Final Thoughts The Set and Reduce methods might look simple, but when used right, they can drastically improve performance, clarity, and scalability. ✨ Set = Instant lookups ✨ Reduce = Powerful transformations #JavaScript #WebDevelopment #CodingTips #CodeOptimization #ReduceMethod #SetInJavaScript #CleanCode #ProgrammingMindset #SoftwareEngineering #DevelopersJourney
Explore content categories
- Career
- Productivity
- Finance
- Soft Skills & Emotional Intelligence
- Project Management
- Education
- Technology
- Leadership
- Ecommerce
- User Experience
- Recruitment & HR
- Customer Experience
- Real Estate
- Marketing
- Sales
- Retail & Merchandising
- Science
- Supply Chain Management
- Future Of Work
- Consulting
- Writing
- Economics
- Artificial Intelligence
- Employee Experience
- Workplace Trends
- Fundraising
- Networking
- Corporate Social Responsibility
- Negotiation
- Communication
- Engineering
- Hospitality & Tourism
- Business Strategy
- Change Management
- Organizational Culture
- Design
- Innovation
- Event Planning
- Training & Development