Question 1

In database technology, what is a Relational Database Management System (RDBMS) and what are some of its key features?

Accepted Answer

Introduction / Context: Relational Database Management Systems, or RDBMS, are widely used to store and manage structured data in applications ranging from banking to e commerce. Common examples include Oracle Database, MySQL, PostgreSQL and SQL Server. In technology interviews, candidates are often asked to define RDBMS and describe its core features. This question checks whether you understand the relational model and standard capabilities of an RDBMS. Given Data / Assumptions: The term RDBMS refers to systems based on the relational model proposed by E F Codd. Data is organised logically as relations, typically represented by tables. Users interact with the database using SQL or similar query languages. Concept / Approach: An RDBMS stores data in tables with rows representing records and columns representing attributes. Relationships between tables are implemented using primary keys and foreign keys, and integrity constraints help maintain consistency. RDBMS products also provide transaction management with ACID properties, ensuring that operations are atomic, consistent, isolated and durable. The correct option therefore needs to mention relational tables, SQL support, relationships and transactional features. Step-by-Step Solution: Step 1: Recall that relational databases use tables, rows and columns as the core storage structure.Step 2: Identify that RDBMS products support SQL for querying and manipulating data.Step 3: Recognise that keys and constraints enforce relationships and maintain data integrity, while ACID transactions ensure safe multi step operations.Step 4: Option A describes all these aspects clearly, mentioning the relational model, tables, SQL, keys, constraints and ACID transactions.Step 5: Options B, C and D do not describe relational databases at all, so option A is correct. Verification / Alternative check: Standard database textbooks define an RDBMS as a database management system that is based on the relational data model and uses a declarative query language such as SQL. They highlight features such as data independence, integrity constraints and support for concurrent transactions. Option A aligns with these definitions, confirming its accuracy as a summary of what an RDBMS is. Why Other Options Are Wrong: Option B describes a plain file system without the structure, query language or constraints that make up an RDBMS. Option C refers to a graphical tool for drawing network diagrams, which is unrelated to database management. Option D talks about operating systems in general, which can host databases but are not themselves RDBMS. Common Pitfalls: Some learners confuse RDBMS with generic DBMS and forget to mention the relational model and keys. Others mix up SQL with the database engine itself. It is also common to forget ACID properties when describing features. In interviews, always mention tables, SQL, keys and constraints and ACID transactions as the core features of RDBMS technology. Final Answer: A database management system based on the relational model that stores data in tables with rows and columns, supports SQL, enforces relationships through keys and constraints and provides ACID transactions.

Question 2

In the C programming language, what is a function prototype and what are its main advantages for compiling and using functions?

Accepted Answer

Introduction / Context: Function prototypes are an important concept in C programming. They appear at the top of source files or in header files and tell the compiler what a function looks like before its actual definition or calls appear. Understanding prototypes is essential for writing multi file programs, avoiding implicit declarations and catching type related errors at compile time rather than at run time. Given Data / Assumptions: The language considered is C, where function prototypes are commonly used. A function prototype must specify at least the function name, return type and parameter list. The compiler uses this information when checking function calls. Concept / Approach: A function prototype is a declaration that describes the interface of the function. It has the same form as the function header but ends with a semicolon and has no body. By placing this prototype before any calls, the compiler knows what types to expect for arguments and the return value. This prevents errors such as passing wrong types or wrong number of arguments. It also enables type conversions where appropriate. The correct option must mention declaration, parameter types and compile time checking. Step-by-Step Solution: Step 1: Recall that a typical function prototype in C looks like: int add(int a, int b);Step 2: Note that this line appears before main or in a header file and is distinct from the full definition which includes the body.Step 3: The main advantage is that the compiler can verify each call to add for correct argument count and types.Step 4: Option A states that a prototype is such a declaration and explains the benefit of compile time checking.Step 5: Options B, C and D describe behaviour that does not match the role of function prototypes, so option A is correct. Verification / Alternative check: If pre C89 style code omits prototypes, the compiler may assume default int return type and may not correctly check parameters. This often leads to warnings or undefined behaviour. Modern C standards require proper prototypes. Textbooks emphasise that prototypes improve type safety and make multi file compilation easier. Option A reflects this widely accepted explanation of prototypes and their advantages. Why Other Options Are Wrong: Option B sounds like the main function, which is a specific entry point, not a prototype. Option C suggests a temporary debugging copy, which is not how prototypes work. Option D confuses prototypes with macros or inline expansion, which are different features. Common Pitfalls: Beginners sometimes confuse function prototypes with definitions or think they are optional decoration. Others forget to update prototypes when changing function signatures, leading to mismatches. Always remember that a prototype is about the interface, not the implementation, and its main advantage is type checking at compile time. Final Answer: A declaration of a function that specifies its name, return type and parameter types before it is used, which allows the compiler to check calls for correct number and type of arguments.

Question 3

In web development, which of the following actions cannot be performed directly by client side JavaScript running in a browser for security reasons?

Accepted Answer

Introduction / Context: Client side JavaScript runs inside the user's browser and is limited by security rules called the same origin policy and sandboxing. While JavaScript can do many interactive tasks on web pages, it cannot directly access server resources such as database files without going through server side code. This question tests whether you can distinguish between tasks that are possible in client side scripts and those that require server side support. Given Data / Assumptions: JavaScript here refers to code executed in a browser, not Node.js on the server. The environment follows normal web security practices. We consider common operations around HTML forms and data storage. Concept / Approach: Client side JavaScript can read form values, validate them, show error messages and send data to the server using form submission or asynchronous requests. However, it cannot open or write to files on the server or manipulate the database directly. That responsibility belongs to server side technologies such as PHP, Java, Python or Node.js with appropriate database drivers. The correct option therefore must describe an action that would require direct server file or database access without server side code, which is not allowed from pure client side scripts. Step-by-Step Solution: Step 1: Check each option to see whether it involves only browser side activity or direct server side file or database access.Step 2: Option A describes sending form contents to a server side script, which is possible via form submission or fetch or Ajax.Step 3: Option C and option D describe validation and displaying error messages, which are classic use cases for client side JavaScript.Step 4: Option B talks about directly storing form contents into a database file on the server with no server side code, which is not possible because browser scripts cannot open server database files.Step 5: Therefore, option B is the correct answer because it describes something client side JavaScript cannot do. Verification / Alternative check: If client side scripts could write directly to server databases, any third party page or attacker could tamper with data simply by running JavaScript in a browser, which would be a serious security hole. Instead, all database operations must pass through authenticated server side logic. Documentation for web security emphasises that JavaScript in the browser can only communicate with the server over HTTP or HTTPS and cannot bypass server side protections. Option B violates this rule and is therefore impossible for pure client side code. Why Other Options Are Wrong: Option A is possible because sending data to the server is exactly what forms and asynchronous requests are designed to do. Option C is a standard practice where JavaScript checks field formats before submission. Option D is also a common behaviour where scripts update the page dynamically to show error messages or hints. Common Pitfalls: Beginners sometimes think that because JavaScript can send data to the server, it is directly writing to the database. In reality, the server decides what to do with the data. Another mistake is confusing client side JavaScript with server side JavaScript environments. When answering such questions, always think about where the code runs and what resources it can and cannot access. Final Answer: Directly storing a form's contents into a database file on the server without any server side code.

Question 4

In web technologies, what is Dynamic HTML (DHTML) and what are some important features that distinguish it from static HTML pages?

Accepted Answer

Introduction / Context: Dynamic HTML, often abbreviated as DHTML, is a term used to describe web pages that change interactively in the browser without requiring a full page reload from the server. Although the term is older and less used today, the underlying idea remains central to modern web development. Understanding DHTML helps clarify how HTML, CSS and JavaScript work together to create interactive user experiences. Given Data / Assumptions: DHTML is not a separate language but a combination of technologies. Browsers provide a Document Object Model, or DOM, to allow scripts to manipulate page elements. The goal is to update content and presentation dynamically on the client side. Concept / Approach: A DHTML page uses HTML to define structure, Cascading Style Sheets to control presentation, JavaScript to program behaviour and the DOM to access and modify elements. With these tools, the page can respond to events such as clicks and mouse movements, change styles, show or hide elements, and update content without contacting the server for every change. The correct option must therefore describe DHTML as a combination of technologies that enables dynamic manipulation of web pages in the browser. Step-by-Step Solution: Step 1: Recall that DHTML is an umbrella term that includes HTML, CSS, JavaScript and DOM scripting.Step 2: Recognise that its main feature is the ability to change page content and appearance interactively without reloading.Step 3: Option A presents DHTML exactly this way, mentioning HTML, CSS, JavaScript, DOM and dynamic updates based on user actions.Step 4: Options B, C and D describe unrelated technologies and do not refer to interactive pages.Step 5: Therefore, option A is the correct definition and feature summary for DHTML. Verification / Alternative check: If you look at classic examples of DHTML, they include animated menus, expanding sections and drag and drop elements implemented purely on the client side. All such features rely on JavaScript modifying HTML elements and CSS styles through the DOM. No separate language called DHTML exists. This confirms that any correct definition must emphasise the combination of technologies, as option A does. Why Other Options Are Wrong: Option B incorrectly suggests that DHTML is a new mobile only version of HTML. Option C confuses DHTML with server side scripting, which runs on the server rather than in the browser. Option D describes a file format for images or animations, which is not DHTML. Common Pitfalls: Some learners think that DHTML is an outdated or separate language instead of a concept. Others mix up dynamic pages that reload from the server with dynamic behaviour entirely in the browser. To avoid confusion, remember that DHTML refers specifically to client side techniques that update the page in place using scripts and styles. Final Answer: A combination of HTML, CSS, JavaScript and the Document Object Model that allows web pages to change content, style and layout dynamically in response to user actions without reloading the whole page.

Question 5

In data structures, what is the main difference between a stack and an array when they are used to store elements in memory?

Accepted Answer

Introduction / Context: Arrays and stacks are fundamental structures used to hold collections of elements in memory. Many interview and exam questions ask for the difference between them to check whether you understand not only memory layout but also the operations allowed on each structure. This question focuses on how access patterns and usage rules differ between a general array and a stack abstract data type. Given Data / Assumptions: An array is a contiguous block of memory with indexed elements. A stack is an abstract data type that can be implemented using arrays or linked lists. Stacks follow the Last In First Out, or LIFO, principle for insert and delete operations. Concept / Approach: In an array, any element can be accessed directly by its index in constant time, and the structure does not impose rules on where you insert or remove elements, though such operations may shift data. In a stack, operations are restricted to one end, called the top. Push adds an element to the top and pop removes the most recently added element. This restriction defines the stack behaviour. Therefore, the correct option must explain free random access in arrays versus restricted LIFO access in stacks. Step-by-Step Solution: Step 1: Recall that arrays support random access and can be used in many different ways.Step 2: Recall that stacks expose only push, pop and sometimes peek operations on the top element.Step 3: Option A states that arrays allow random index based access and stacks are restricted to one end with LIFO discipline.Step 4: Option B introduces a false restriction on data type for stacks, and option C makes incorrect statements about automatic resizing.Step 5: Option D wrongly claims there is no difference, so option A is correct. Verification / Alternative check: You can check this by considering common uses. A stack is often used for function call management and undo operations, where you always remove the most recent element. An array is used for general storage such as an array of scores or names where you frequently access arbitrary positions. Implementation wise, a stack may use an array internally, but the interface imposed on the programmer is more restricted than direct array access. This confirms the description given in option A. Why Other Options Are Wrong: Option B is wrong because stacks can store any data type depending on the implementation and programming language. Option C is incorrect because arrays do not automatically resize in many languages and stacks may be implemented as dynamic structures. Option D ignores the conceptual differences between the two structures. Common Pitfalls: Students sometimes confuse how something is implemented with what operations are allowed. They may say that a stack is an array, when more precisely a stack can be implemented by an array. Remember that an abstract data type is defined by permitted operations and behaviour, not by a specific implementation detail. Final Answer: An array is a linear collection that allows random access to any element by index, while a stack is a restricted structure that allows insertion and removal only at one end using a Last In First Out discipline.

Question 6

In SQL, which operator is commonly used in a WHERE clause to perform pattern matching on character data?

Accepted Answer

Introduction / Context: Pattern matching on strings is a frequent requirement in database queries. For example, you might want all customers whose names start with a certain letter or all products that contain a specific word in their description. SQL provides operators to support such pattern based searches. This question asks you to identify the standard operator used in WHERE clauses for simple pattern matching on character data. Given Data / Assumptions: The database language considered is SQL. We are working with character or text columns. The goal is to match patterns such as starting with or containing a substring. Concept / Approach: The LIKE operator in SQL allows you to specify patterns using wildcard characters such as percent and underscore. For example, name LIKE 'A%' matches any value starting with A, and name LIKE '%son' matches any value ending with son. EXISTS and BETWEEN operators have different purposes: EXISTS checks for the existence of rows in a subquery and BETWEEN checks whether a value lies in a range. Therefore, LIKE is the correct choice for pattern matching. Step-by-Step Solution: Step 1: Recall that pattern matching typically uses wildcard characters like percent and underscore.Step 2: Remember that in SQL, these wildcards are used with the LIKE operator in WHERE conditions.Step 3: Option A explicitly names the LIKE operator.Step 4: Option B, EXISTS, is used to test whether a subquery returns at least one row and is not for pattern matching.Step 5: Option C, BETWEEN, checks if a value lies between two given values, which is different from string patterns, while option D is incorrect because a suitable operator does exist. Verification / Alternative check: Examples from any SQL tutorial show statements such as SELECT * FROM employees WHERE first_name LIKE 'J%'; to find employees whose first name starts with J. There is no way to perform this simple pattern based filtering with BETWEEN or EXISTS. This practical usage confirms that LIKE is the required operator for basic pattern matching on text values. Why Other Options Are Wrong: Option B, EXISTS, evaluates to true if the subquery returns any rows and is commonly used for correlated subqueries. Option C, BETWEEN, is generally applied to numeric or date fields to check ranges and not for substring matching. Option D is wrong simply because the LIKE operator is available for this purpose. Common Pitfalls: Beginners sometimes confuse LIKE with equality or try to use range conditions for partial text matching. Another pitfall is forgetting that LIKE with wildcards can be slower on large tables if indexes are not used properly. However, for exam purposes, it is enough to remember that LIKE is the keyword for simple pattern matching in SQL WHERE clauses. Final Answer: LIKE operator

Question 7

Which statement best describes how web pages on the World Wide Web are organised and connected?

Accepted Answer

Introduction / Context: The World Wide Web is one of the most visible parts of the internet. It consists of millions of web pages that users access through browsers. Understanding how these pages are stored and connected helps clarify basic concepts in internet and web technology. This question asks you to identify the statement that best describes the organisation and linkage of web pages on the World Wide Web. Given Data / Assumptions: Web pages are retrieved via HTTP or HTTPS protocols over the internet. They are stored on many different web servers around the world. Hyperlinks allow users to move between related pages easily. Concept / Approach: Each website typically runs on a web server, which may be located anywhere in the world and connected to the internet. Web pages are written in HTML or other markup languages and made available through URLs. Hyperlinks inside pages point to other pages on the same or different servers, creating a web like structure. The correct option must therefore mention distribution across many computers and linking via hyperlinks, not central storage or complete lack of markup. Step-by-Step Solution: Step 1: Recall that there is no single central computer for all web pages; instead, many servers host different sites.Step 2: Remember that pages are connected by hyperlinks which allow clicking from one page to another.Step 3: Option A says that pages reside on many computers connected through the internet and are linked using hyperlinks, which reflects this reality.Step 4: Option B claims that all pages reside on a single central computer, which is false.Step 5: Options C and D deny network access or the use of HTML, which contradicts basic facts about the web, so option A is correct. Verification / Alternative check: If you type different URLs into a browser, you connect to different servers as shown by different domain names. The browser fetches HTML content from those servers and follows hyperlinks embedded in the pages. This everyday experience confirms that web pages are distributed and interconnected, matching the description in option A. Why Other Options Are Wrong: Option B imagines a centralised web, which would be a single point of failure and does not match how the real web is built. Option C ignores the network nature of the web by claiming that pages are only on local drives. Option D claims that web pages are always created without HTML or any markup, which conflicts with the fundamental role of HTML in the World Wide Web. Common Pitfalls: Some learners confuse the internet, which is the underlying network of networks, with the World Wide Web, which is the system of linked documents accessed over that network. Others underestimate the importance of hyperlinks in making navigation possible. Always remember that the web is a distributed, hyperlinked collection of documents stored on many servers worldwide. Final Answer: They reside on many computers connected through the internet and are linked to each other using hyperlinks so that users can navigate from one page to another.

Question 8

In hash table design, which option correctly lists two main types of collision resolution techniques and example methods used in each type?

Accepted Answer

Introduction / Context: Hash tables are widely used for fast insertion and lookup of key value pairs. However, collisions occur when different keys hash to the same table index. Collision resolution techniques are strategies used to handle these collisions while preserving good average performance. Interview and exam questions often ask you to name the main categories of collision resolution and to give typical methods in each category. This question focuses on that conceptual understanding in the context of data structures and algorithms. Given Data / Assumptions: We are discussing hash tables used in memory based data structures, not cryptographic hash functions. Two widely taught categories are open addressing and separate chaining. Typical methods in open addressing include linear probing, quadratic probing and double hashing. Concept / Approach: In open addressing, all elements are stored directly in the hash table array. When a collision occurs, the algorithm probes other slots according to a fixed rule until it finds an empty position. Linear probing checks the next slot, quadratic probing uses a quadratic step, and double hashing uses a second hash function to determine the probe sequence. In separate chaining, each cell of the hash table points to a linked list or another secondary structure where colliding elements are stored. The correct option must mention both categories and give appropriate examples of methods. Step-by-Step Solution: Step 1: Recall from theory that the two main types of collision resolution are open addressing and chaining.Step 2: List typical open addressing methods such as linear, quadratic and double hashing.Step 3: Recognise that chaining involves attaching a list of keys to each bucket to hold colliding entries.Step 4: Option A describes open addressing with its probing methods and separate chaining using linked lists.Step 5: Options B, C and D mention algorithms or techniques that do not represent standard hash collision resolution methods, so option A is correct. Verification / Alternative check: Data structures textbooks classify collision resolution schemes exactly in this way. They show diagrams of hash tables using linear probing and of hash tables where each slot refers to a chain of nodes. Sorting algorithms and tree structures can be used for other purposes, but they are not the primary names used for hash collision resolution categories. This confirms that option A reflects the standard classification. Why Other Options Are Wrong: Option B lists sorting algorithms, which are not designed to resolve hash collisions. Option C lists tree based methods without mentioning that trees are usually separate structures rather than primary hash collision resolution categories. Option D refers to random numbers and encryption, which may be used in hash function design but are not collision resolution techniques in the usual sense. Common Pitfalls: Students sometimes remember the names of individual methods like linear probing but forget the categories they belong to. Others confuse the hash function design with collision handling. To avoid mistakes, keep clear that collision resolution in hash tables is mainly about open addressing versus chaining, with probing rules as subtypes of open addressing. Final Answer: Open addressing techniques such as linear probing, quadratic probing and double hashing, and separate chaining techniques where each table slot points to a linked list of entries.

Question 9

In standard SQL, which query correctly displays the current date returned by the database using the CURRENT_DATE function?

Accepted Answer

Introduction / Context: Most relational databases provide built in functions to return the current date and sometimes the current date and time. Knowing the standard SQL way to request the current date is useful for writing portable queries that run on different database systems. This question focuses on the CURRENT_DATE function defined in the SQL standard and tests whether you can identify the correct syntax to display the current date. Given Data / Assumptions: The database supports standard SQL syntax. The goal is to display the current date as returned by the server. CURRENT_DATE is used as a function or special value that returns today's date. Concept / Approach: In standard SQL, CURRENT_DATE is an ANSI SQL function like CURRENT_TIME and CURRENT_TIMESTAMP. It can be selected without a FROM clause in many systems or with a dummy table in some implementations. The simplest form in many databases is SELECT CURRENT_DATE;. Other options in the list, such as SYSDATE FROM dual, are specific to particular platforms like Oracle and are not the standard portable answer requested in the question. Therefore, the correct choice is the query that uses CURRENT_DATE directly. Step-by-Step Solution: Step 1: Recall that the SQL standard provides CURRENT_DATE to fetch today's date.Step 2: Identify the option that uses this name correctly in a SELECT statement.Step 3: Option A is SELECT CURRENT_DATE; which is the canonical form in many SQL engines and matches the standard.Step 4: Option B uses SYSDATE FROM dual, which is Oracle specific. Option C uses NOW without parentheses and a dummy table, which is not standard. Option D uses DATE() against a table, which does not necessarily return the current date.Step 5: Choose option A as the correct standard SQL query. Verification / Alternative check: Documentation for PostgreSQL, MySQL and other systems shows examples where CURRENT_DATE can be used directly in a SELECT statement. In PostgreSQL you can run SELECT CURRENT_DATE; and in MySQL you can use SELECT CURRENT_DATE; or SELECT CURDATE();. Although many systems also support proprietary functions, CURRENT_DATE is the most portable across compliant databases, which is why it is highlighted in standard focused exam questions. Why Other Options Are Wrong: Option B is valid in Oracle where dual is a special dummy table and SYSDATE returns the system date and time, but it is not standard and fails on databases that do not have dual. Option C uses NOW incorrectly and is incomplete or non standard without parentheses, and NOW is not part of the core SQL standard. Option D misuses DATE() on a specific table and would depend on the column being used, so it does not represent a general way to get the current date. Common Pitfalls: Many students memorise platform specific functions such as GETDATE(), SYSDATE or NOW() and then forget which one is portable. In certification exams that emphasise generic SQL, questions often prefer the standard CURRENT_DATE syntax. To reduce confusion, remember that CURRENT_DATE, CURRENT_TIME and CURRENT_TIMESTAMP are part of the SQL standard and are safe answers when cross platform behaviour is discussed. Final Answer: SELECT CURRENT_DATE;

Question 10

In SQL, which query correctly finds the number of employees grouped by gender whose date of birth is between 1 January 1960 and 31 December 1975, inclusive?

Accepted Answer

Introduction / Context: Grouping and filtering are core skills in SQL. Many business reports need counts of employees by categories such as gender or department, filtered by conditions like date of birth ranges. This question checks your ability to combine a WHERE clause with a BETWEEN condition on dates and a GROUP BY clause on gender. Understanding the correct ordering of clauses and the meaning of BETWEEN is essential for writing accurate queries. Given Data / Assumptions: There is an employees table with at least two columns: gender and dob (date of birth). Dates are stored in a standard format such as YYYY-MM-DD. The requirement is to include employees born from 1 January 1960 to 31 December 1975, both dates inclusive. Concept / Approach: The BETWEEN operator in SQL is inclusive at both ends, so dob BETWEEN '1960-01-01' AND '1975-12-31' selects all rows where dob is on or between these dates. To count employees by gender, we select gender and COUNT(*) and then group by gender so that one row is produced per gender with the corresponding count. The correct query therefore needs SELECT gender, COUNT(*), a WHERE clause with the correct BETWEEN condition and a GROUP BY gender clause. Step-by-Step Solution: Step 1: Identify the required columns in the result: gender and count of employees per gender.Step 2: Form the WHERE condition to restrict dob to the inclusive range between 1960-01-01 and 1975-12-31.Step 3: Add GROUP BY gender so that counts are calculated separately for each gender value.Step 4: Option A writes exactly this: SELECT gender, COUNT(*) FROM employees WHERE dob BETWEEN '1960-01-01' AND '1975-12-31' GROUP BY gender;.Step 5: Options B, C and D misuse the date conditions or omit the grouping and counting logic, so option A is correct. Verification / Alternative check: To verify, imagine a small sample table with a few rows and manually apply the condition. Any employee born in 1965 should be included, and the same for 1970 or exactly on 1960-01-01 or 1975-12-31. The BETWEEN clause in option A includes those boundary dates. Option B reverses the range and uses strict inequalities, which will select no rows. Option C only includes two exact dates, ignoring the full interval. Option D does not count employees, it just returns multiple rows containing gender values. Why Other Options Are Wrong: Option B uses dob greater than 1975-12-31 and less than 1960-01-01 in the same condition, which can never be true for any row, and therefore returns zero results. Option C restricts the selection to employees whose dob matches exactly the two dates, not the full range. Option D selects gender only and does not perform any aggregation, so it does not satisfy the requirement of counting employees by gender. Common Pitfalls: Common mistakes include forgetting the GROUP BY clause when using aggregate functions, reversing the order of dates in BETWEEN, or misunderstanding that BETWEEN is inclusive. Some developers also hard code dates in formats that do not match the database settings, causing unexpected results. For exam and interview questions, always write dates in a clear format like YYYY-MM-DD and double check that the WHERE condition matches the verbal requirement. Final Answer: SELECT gender, COUNT(*) FROM employees WHERE dob BETWEEN '1960-01-01' AND '1975-12-31' GROUP BY gender;

Question 11

In a typical web environment, JavaScript code embedded in an HTML page is interpreted and executed primarily on which side?

Accepted Answer

Introduction / Context: JavaScript is a core technology of the web alongside HTML and CSS. In its most common use, JavaScript runs inside the browser to add interactivity to web pages. Interview questions often test whether candidates understand where JavaScript is executed in the classic client server model. This question focuses on the typical scenario of JavaScript embedded in HTML pages viewed in a standard web browser. Given Data / Assumptions: We are considering traditional client side JavaScript, not server side environments such as Node.js. HTML pages are loaded into a web browser on the user's device. JavaScript code is interpreted by a JavaScript engine integrated into the browser. Concept / Approach: In the client server model, the server delivers HTML, CSS and JavaScript files to the client. Once received, the browser parses the HTML, applies styles and runs any JavaScript using its built in engine. The code manipulates the Document Object Model to update the page, respond to events and send requests back to the server when needed. Therefore, JavaScript embedded in web pages is interpreted on the client side, which typically means the user's browser on their device. Step-by-Step Solution: Step 1: Recall that browsers such as Chrome, Firefox and Edge contain JavaScript engines like V8 or SpiderMonkey.Step 2: These engines interpret and execute scripts included in HTML pages after they are downloaded from the server.Step 3: This work happens on the client device, not on the web server itself.Step 4: Option C, client, correctly identifies where the code is interpreted in this typical scenario.Step 5: Options A, B and D do not match the standard behaviour of client side JavaScript, so option C is correct. Verification / Alternative check: If you disable JavaScript in your browser settings, client side scripts stop running even though the server still sends the same HTML and JS files. This shows that execution is taking place on the client. Server side scripts such as PHP or Python run on the server before the page is sent. The separation of responsibilities between server and client in web architecture reinforces that classic JavaScript in HTML pages is interpreted on the client side. Why Other Options Are Wrong: Option A, server, describes environments where scripts are executed on the server, which is true for some technologies but not for standard client side JavaScript in HTML pages. Option B, object, is not a side in the client server model and does not answer the question. Option D, none of the above, is wrong because there is a clear correct answer among the options. Common Pitfalls: Confusion may arise because JavaScript can also run on the server in platforms such as Node.js. In exam questions, however, unless server side JavaScript is explicitly mentioned, you should assume the classic browser context. Pay attention to words like embedded in an HTML page and web browser to guide your answer to client side execution. Final Answer: Client

Question 12

In client side web scripting, what is the correct JavaScript syntax to write the text Hello World into the current HTML document?

Accepted Answer

Introduction / Context: This question checks basic familiarity with JavaScript syntax and the difference between JavaScript and other programming languages. Beginners often confuse JavaScript syntax with that of Java or server side languages. A very common example in tutorials is writing Hello World into the web page using JavaScript. Knowing the correct syntax helps confirm that you understand the context in which the code runs and the correct object and method names. Given Data / Assumptions: The environment is client side JavaScript running in a browser. We want to output the text Hello World to the HTML document. The method must be valid JavaScript, not Java or other language syntax. Concept / Approach: In JavaScript, the global document object represents the current HTML document. The document.write method can output a string directly into the document stream. The correct call uses the method name on the document object and passes the text in quotes. System.out.println is a Java method used in console applications, println alone is not defined by default in JavaScript and response.write is associated with some server side environments, not client side scripts. Therefore, the correct answer uses document.write with the desired string. Step-by-Step Solution: Step 1: Identify that we are working with JavaScript in a browser, not with Java or ASP.Step 2: Recall that document.write("Hello World"); is a textbook example of writing to the page in JavaScript.Step 3: Option C matches this syntax exactly, using the document object and write method with the string argument.Step 4: Option A is Java syntax for printing to the console, not JavaScript.Step 5: Option B is incomplete and does not refer to any defined function, and option D relates to server side scripting, so option C is correct. Verification / Alternative check: If you include a script tag in an HTML page and write document.write("Hello World"); inside it, loading the page in a browser will display Hello World at the point where the script executes. Trying System.out.println in the same context raises an error because System is not defined in JavaScript. This direct experiment confirms that document.write is the correct method to use in this simple example. Why Other Options Are Wrong: Option A belongs to the Java language, not JavaScript, even though their names are similar. Option B omits the object that owns the method and is not standard JavaScript. Option D corresponds to response.write in some server side technologies such as classic ASP, which are executed on the server, not in the browser. Common Pitfalls: A very common mistake is to confuse Java with JavaScript because of the similar names. Another pitfall is to assume that functions like println are globally available, which is not true in JavaScript. While document.write is rarely used in modern applications for dynamic updates, it remains a simple teaching example and often appears in introductory interview questions. Final Answer: document.write("Hello World");

Question 13

In programming, which parameter passing mechanism is generally more effective when a function needs to modify a large object passed from the caller?

Accepted Answer

Introduction / Context: Different programming languages support different parameter passing mechanisms. When functions receive parameters, the way values are passed affects both performance and the ability to modify the original arguments. This question focuses on the scenario where a function needs to modify a large object, such as a large structure or class instance, and asks which mechanism is generally more effective in that case. The answer is relevant in languages like C++ that distinguish clearly between call by value and call by reference. Given Data / Assumptions: The object being passed is large enough that copying it is relatively expensive. The function is expected to modify the original object, not just a local copy. We are considering common language designs where references or pointers allow functions to work with the original data. Concept / Approach: Under call by value, the function receives a copy of the argument, so modifications inside the function do not affect the original and copying may be expensive for large objects. Under call by reference, the function receives an alias or reference to the original object, so no full copy is made and any changes are applied directly to the caller's data. Call by pointer is similar in effect but uses explicit pointers and dereferencing; the question asks generally which mechanism is more effective in the described scenario, and most textbooks highlight call by reference for this purpose in modern high level languages. Step-by-Step Solution: Step 1: Consider the cost of copying large objects when using call by value.Step 2: Consider the necessity of modifying the original object, which is not possible with pure call by value without returning the object.Step 3: Recognise that call by reference passes an alias to the existing object without copying and allows direct modification.Step 4: Option B, call by reference, matches this reasoning and is commonly recommended for functions that must modify large arguments.Step 5: Option C, call by pointer, can achieve similar results but usually requires more careful syntax; option A does unnecessary copying, and option D is not meaningful as an answer. Verification / Alternative check: In C++, many function signatures use references for parameters that are to be modified or are large objects, for example void updateOrder(Order and order). This avoids copying and clearly communicates that the function will work with the caller's data. Guides on performance and memory usage recommend passing large objects by reference or by reference to const, rather than by value. This practice confirms that call by reference is considered more effective in the scenario described. Why Other Options Are Wrong: Option A, call by value, forces a full copy of the object and prevents direct modification of the original, making it less efficient and less suitable for this use case. Option C, call by pointer, can be effective but typically introduces additional complexity with null checks and explicit dereferencing; the more modern and straightforward recommendation in many languages is call by reference. Option D does not answer the question and suggests no mechanism, which is not helpful. Common Pitfalls: Students sometimes assume that call by value is always better because it seems safer, ignoring performance costs for large objects. Others treat pointers and references as identical in all languages, which is not accurate. A good rule of thumb in C++ is to use references for parameters that should be modified or for large objects to avoid copying, reserving call by value for small types like integers where copying is cheap. Final Answer: call by reference

Question 14

In traditional C programming, if a function was declared without any explicit return type in old style code, what was the default return type assumed by the compiler?

Accepted Answer

Introduction / Context: Earlier versions of the C programming language allowed functions to be declared without explicitly specifying a return type. In such old style code, the compiler would assume a default return type. Modern C standards discourage this practice and require explicit declarations, but understanding the historical rule remains useful for reading legacy code and for answering interview questions about language evolution. This question focuses on that default return type. Given Data / Assumptions: The context is traditional or pre ANSI C, sometimes called K and R C. A function is written without specifying a return type before its name. The compiler follows the old rule instead of issuing a hard error. Concept / Approach: In old style C, if you wrote a function like sum(a, b) without a type before the name, the compiler implicitly treated the function as returning an int. Similarly, if a function was used before being declared, it was implicitly assumed to return int. This behaviour could lead to subtle bugs and was removed or restricted in later standards. Therefore, the correct answer must be the int type, not void or any floating point type. Step-by-Step Solution: Step 1: Recall the historical rule: functions without explicit type default to int.Step 2: Compare the options and identify which one matches this rule.Step 3: Option A is int, which is the type assumed in old C compilers for undeclared function return types.Step 4: Options B, C and D represent other common types but were not used as default return types.Step 5: Therefore, option A is correct for the historical default behaviour. Verification / Alternative check: Classic C programming books by Kernighan and Ritchie mention that int is the default type for functions and variables when no type is given. Compilers following older standards would issue warnings but still treat such functions as returning int. In contrast, modern compilers with strict standard settings reject such code. This confirms that int is the correct answer in questions that explicitly refer to default return type in old style C. Why Other Options Are Wrong: Option B, void, is sometimes used now for functions that do not return a value, but it must be specified explicitly; it was not used as a default. Option C, float, and option D, char, were never used as default return types; they are used only when declared. Choosing any of these would be inconsistent with the language rules described in older C standards. Common Pitfalls: Modern programmers, accustomed to explicit typing and strict compiler checks, may guess void as the default, thinking that absence of type means no return value. Others may not be aware of old style C at all. For exam purposes, it is important to remember that historically int was the default type, and that this rule is one reason why explicit function prototypes and types are now strongly recommended. Final Answer: int

Question 15

In C++ object oriented programming, what is a friend function and how does it relate to the class that declares it as a friend?

Accepted Answer

Introduction / Context: C++ supports the concept of friend functions as part of its access control mechanisms. Normally, only member functions of a class can access its private and protected data. However, in some designs it is convenient to allow certain non member functions or functions of other classes to access those members directly. Friend declarations provide a controlled way to grant such access without making the members public. This question tests whether you understand what a friend function is and how it is related to the class that declares it. Given Data / Assumptions: The programming language is C++. We are discussing access control keywords such as private, protected and public. Friendship is declared inside the class whose members are to be accessed. Concept / Approach: A friend function is specified using the friend keyword in the class definition. For example, friend void display(const MyClass and obj);. This line inside MyClass allows the non member function display to access private and protected members of MyClass. Friend functions are not class members, so they are called like normal functions, but they enjoy special access rights. Friendship is not symmetric or transitive; it must be explicitly granted by each class. The correct option must mention that a friend function is granted access to private and protected members through an explicit friend declaration. Step-by-Step Solution: Step 1: Recall that without friend, only member functions and classes derived in certain ways can access non public members.Step 2: Remember that friend functions are declared using the friend keyword inside the class.Step 3: Option A states that a non member or member function is granted access to private and protected members of a class by being declared as a friend inside that class.Step 4: Options B, C and D describe behaviours that are unrelated to friend functions in C++.Step 5: Therefore, option A accurately captures the definition and relationship. Verification / Alternative check: If you implement an operator overload like operator<< for output streams, it is common to make it a friend of the class so that it can print private data. Example code shows friend std::ostream and operator<<(std::ostream and os, const MyClass and obj); in the class definition. This real world usage demonstrates that friend functions are normal non member functions with special access granted. It also confirms that friend status must be explicitly declared inside the class. Why Other Options Are Wrong: Option B invents a behaviour unrelated to friendship and describes automatic copying that is actually handled by constructors or assignment operators. Option C claims that friend functions can only access public members, which is the opposite of their purpose, since any function can already access public members without being a friend. Option D suggests that friend functions belong to every class and require no declaration, which contradicts the requirement for explicit friend declarations. Common Pitfalls: Some learners think that friend functions are member functions, but in fact they are usually non members that are granted special access. Others assume that friendship is inherited or global, which it is not. Each class decides exactly which functions or other classes are friends. For exam answers, emphasise explicit friend declarations and extended access to private and protected members as the key characteristics. Final Answer: A non member or member function that is granted access to the private and protected members of a class by being explicitly declared as a friend inside that class.

Question 16

In C++ object oriented programming, which of the following is not actually a member of a class, even though it can access its private data members?

Accepted Answer

Introduction / Context: In C++ object oriented programming, a class encapsulates both data members and member functions. Only some functions are true members of the class, meaning they are part of the class body and are invoked using an object or the class name. Friend functions are often confusing, because they can see private and protected members, yet they are not members of the class itself. This question tests clear understanding of which functions belong to the class and which do not. Given Data / Assumptions: The class can declare normal member functions, static member functions, virtual functions, and const qualified functions. The class can also declare non member functions as friends using the friend keyword. Friend functions have special access rights, but they are still ordinary functions at global or other namespace scope. The question asks which option is not a member of the class, even though it may have access to private data. Concept / Approach: Any function defined inside the class body or declared as a member is a true member function. This includes virtual functions, static functions, and const qualified member functions. A friend function is declared with the friend keyword inside the class, but it is not a member. The main effect of friend is to grant access to private and protected members, not to change the function's scope. Member functions are called using object.member() or ClassName::member(), while friend functions are called like normal free functions. Step-by-Step Solution: Step 1: Note that a virtual function is simply a member function marked virtual to support dynamic binding. It is still a member of the class. Step 2: A static function is a member function associated with the class rather than any specific object, but it is still declared inside the class and is part of the class interface. Step 3: A const member function is a member whose body is not allowed to modify the object state. It is still clearly a member function. Step 4: A friend function is declared with friend inside the class, but it is defined outside the class without the ClassName:: scope. It is called like a normal function and is not counted as a class member. Verification / Alternative check: If you look at how these functions are defined and called, members use ClassName:: and can be virtual, static, or const, while friend functions do not use ClassName:: in their definition. You can also inspect the class interface in documentation tools, where friend functions are usually shown in a separate friends section rather than in the members list. This confirms that the friend function is not a member of the class. Why Other Options Are Wrong: The virtual function, static function, and const function are all defined as part of the class, so they are true members. The fact that they have special behaviour does not remove them from the class membership. Only the friend function is external to the class while still having access rights. Common Pitfalls: Learners often think that any function declared inside the class body must be a member. They forget that friend is an access grant, not a membership declaration. Another pitfall is to assume that static or virtual status changes membership. Remember that friend functions remain non members with special access privileges. Final Answer: The function that is not a class member is a friend function that has been declared as a friend of the class.

Question 17

In Java, does every class have to declare a main method, or is main required only in the class that serves as the application entry point?

Accepted Answer

Introduction / Context: In Java programming, beginners are often confused about the role of the main method. Many think that every class must contain a main method, because they see examples where execution starts from public static void main(String[] args). In reality, most classes in a real world project do not have a main method at all. Only the entry point class needs it. This question checks whether you understand where main is required and how the Java Virtual Machine JVM starts a program. Given Data / Assumptions: The standard entry point for a Java application is a public static void main(String[] args) method. A project can contain many classes, interfaces, enums, and other types. The JVM is instructed to start execution from a specific class that has an appropriate main method. Supporting classes are instantiated or referenced from that entry point or from other classes, without needing their own main method. Concept / Approach: The main method is a static method with a specific signature. When you run java SomeClass on the command line, the JVM looks inside SomeClass for a main method with the correct signature and begins executing statements inside it. All other classes in the application can define any methods and fields that make sense for the design, and the compiler does not insist on a main method in those classes. Libraries and frameworks often consist entirely of classes that have no main method at all, because they are meant to be used by other applications rather than launched directly. Step-by-Step Solution: Step 1: Recall that the compiler only requires classes to obey Java syntax rules; it does not require every class to define main. Step 2: Understand that the JVM needs exactly one entry point per launched application, which is a public static void main(String[] args) method. Step 3: Recognise that you can have multiple classes with main in a project, but you choose which one to run by specifying the class name when launching the application. Step 4: Note that utility, model, and helper classes are typically created without any main method and are used via references from the entry point or framework code. Step 5: Conclude that main is compulsory only in at least one class that you intend to run as a standalone Java application, not in every class. Verification / Alternative check: You can verify this by writing a simple project with two classes. Let ClassA contain the main method and ClassB contain only a normal instance method. Compile and run ClassA. The program will work correctly even though ClassB has no main method. If you try to run ClassB directly with the java command, the JVM will complain that it cannot find the main method, which shows that main is needed only when you try to start execution from that specific class. Why Other Options Are Wrong: Option b claims that every class must declare main for compilation. This is false because library classes compile and run perfectly without it. Option c mentions abstract classes, which is unrelated to the requirement for main. Option d incorrectly states that main belongs in interfaces, but interfaces cannot contain traditional static main methods in older Java versions, and even in newer versions the entry point is still normally a class, not an interface. Common Pitfalls: A common mistake is to treat main as a magic method that every class needs. Another is to confuse the concept of an entry point with general class design. Keep in mind that main is only the starting location for program execution, while most classes are simply used as building blocks for the application logic. Final Answer: The correct statement is that the main method is required only in the class that serves as the entry point of the application; other supporting classes do not need a main method.

Question 18

In Java exception handling, what is the importance of the finally block and when does the code inside it execute?

Accepted Answer

Introduction / Context: In Java exception handling, the try and catch blocks are widely known for detecting and handling exceptional conditions. However, the finally block is equally important. It provides a guaranteed place to run cleanup code, such as closing files or database connections, regardless of whether an exception was thrown or caught. This question focuses on the role of the finally block and its execution behaviour. Given Data / Assumptions: A try block may or may not throw an exception. One or more catch blocks can handle specific exception types. A finally block, if present, is associated with the same try and catches. Resources such as streams, sockets, or locks should be released reliably to avoid resource leaks. Concept / Approach: The purpose of the finally block is to declare code that must always run after the try and any catch blocks finish. This includes normal completion, completion due to a handled exception, and often even completion due to an exception that propagates further. Finally is ideal for cleanup tasks like closing files, releasing database connections, or restoring states. Without finally, developers might forget to write cleanup in every possible execution path, leading to resource leaks and unpredictable behaviour. Step-by-Step Solution: Step 1: Recall that the basic structure is try { ... } catch(ExceptionType e) { ... } finally { ... }. Step 2: Understand that the code in finally executes after try and catch, whether or not an exception has occurred. Step 3: Note that if an exception is thrown in try and caught in catch, the program runs catch and then finally. Step 4: If no exception is thrown, Java executes the try block completely and then executes finally. Step 5: Recognise that finally is commonly used to close streams, disconnect from databases, release locks, or perform logging that must always happen. Verification / Alternative check: Consider a method that opens a file and reads from it. If you place file closing logic only inside catch blocks, the file will remain open when no exception occurs. If you place it only at the end of the try block, it will not run when an exception is thrown before that point. By moving the close operation into finally, you ensure that the file is always closed, regardless of success or failure. This demonstrates the reliability and importance of the finally block. Why Other Options Are Wrong: Option b suggests that finally catches unchecked exceptions, which is not true; only catch blocks catch exceptions. Option c claims that finally prevents exceptions from being thrown, which is incorrect. Exceptions can still be thrown in try or even inside finally itself. Option d reduces finally to logging only and claims it is ignored when no exception occurs, which directly contradicts the actual behaviour. Common Pitfalls: A frequent mistake is writing complex logic inside finally that itself can throw exceptions and hide earlier problems. Another is forgetting that return statements inside try or catch still trigger finally. Developers should keep finally blocks small, focused on cleanup, and avoid changing control flow unexpectedly. Final Answer: The finally block is important because it defines a block of code that always runs after try and catch, whether an exception is thrown or not, and is typically used to release resources.

Question 19

As a web application developer, how can you make sure that a web application is fit for release to production users?

Accepted Answer

Introduction / Context: Releasing a web application into production without proper checks can lead to downtime, data leaks, and poor user experience. Modern development teams rely on structured release processes to reduce these risks. This question aims to highlight the good engineering practices that help you decide whether a web application is fit for release to real users. Given Data / Assumptions: The application includes server side code, client side code, and a database or external services. Production users expect reliability, security, and acceptable performance. The development team has access to tools such as version control, test frameworks, and staging environments. Unstructured or rushed releases can introduce critical bugs into production. Concept / Approach: A fit for release decision should be based on objective evidence from multiple quality activities, not on gut feeling alone. Good practice includes code reviews to catch logic and style issues, automated unit and integration tests to verify behaviour, user interface and exploratory testing to capture edge cases, and security and performance checks to ensure that the application can handle real load safely. A staging environment that mirrors production is used to test deployment scripts and configuration. When these steps succeed and key metrics look healthy, the release is considered ready. Step-by-Step Solution: Step 1: Ensure that all new code has passed peer review and complies with project standards. Step 2: Run automated unit tests and integration tests to confirm that core functionality works and regressions are not introduced. Step 3: Perform manual functional testing and user interface checks, preferably with test cases derived from user stories. Step 4: Conduct security tests such as input validation checks, authentication and authorisation verification, and vulnerability scanning. Step 5: Run performance and load tests on a staging environment to see whether response times and resource usage remain within acceptable limits. Step 6: Deploy the release candidate to staging using the same scripts that will be used in production, so that deployment itself is tested. Verification / Alternative check: If the team has a history of releasing code that passes all these checks and production incidents remain low, this suggests that the release process is effective. On the other hand, if many problems are discovered by users shortly after release, it is a sign that important steps are missing or not executed well. Comparing these outcomes supports the idea that structured testing and staged deployment are essential to decide release readiness. Why Other Options Are Wrong: Option b relies only on informal testing on a single machine, which is very fragile and does not simulate real environments. Option c pushes testing responsibility onto users, which can damage trust and brand image. Option d focuses only on user interface appearance and ignores security, performance, and core functionality, which are critical for real world use. Common Pitfalls: Teams sometimes skip staging or performance tests under schedule pressure, leading to surprises in production. Another pitfall is having tests that exist but are not kept up to date, producing a false sense of safety. Effective release readiness requires discipline, automation, and realistic environments. Final Answer: A web application is considered fit for release when a structured process including reviews, comprehensive testing, security and performance checks, and staging deployment has been followed and the results are satisfactory.

Question 20

In HTML, what is the difference between a tag and an element?

Accepted Answer

Introduction / Context: When learning HTML, many people casually use the words tag and element as if they mean the same thing. In practice, there is an important distinction. Understanding this difference helps you read documentation, validate your markup, and debug layout issues. This question checks whether you can clearly separate the concept of a tag from that of an element. Given Data / Assumptions: HTML source code uses angle brackets, for example

Hello

. The browser parses tags and builds a Document Object Model DOM made of elements and text nodes. Many HTML constructs have both an opening and a closing tag around content. Some HTML constructs are empty elements, written with only a start tag and no inner content. Concept / Approach: A tag is a piece of markup in the raw HTML text, such as

or

. It is simply the keyword with angle brackets and optional attributes. An element, on the other hand, is the complete logical node in the DOM tree. It includes the start tag, any attributes, the enclosed content (which can be text or child elements), and the end tag. For example, in

Hello

, there are two tags but one paragraph element. This conceptual separation is used in standards and DOM programming. Step-by-Step Solution: Step 1: Look at a simple markup snippet such as

Title

. Step 2: Identify

as the start tag and

as the end tag. These are two distinct tags. Step 3: Recognise that the h1 element consists of the start tag, the text content Title, and the end tag taken together. Step 4: Note that in the DOM, you work with an h1 element node, not with individual tags. Step 5: Choose the option that explicitly states that tags are the bracketed keywords while elements are complete structures including content. Verification / Alternative check: Browser developer tools often show the DOM tree in terms of elements such as html, head, body, div, and span. When you click an element, tools show its start tag, attributes, and end tag as one unit. If you view the page source, you see tags and text. This separation demonstrates that, although related, a tag in source code and an element in the DOM are not the same concept. Why Other Options Are Wrong: Option b claims they are exact synonyms, which ignores how standards and tools use the words. Option c incorrectly associates tags only with attributes and elements only with text. Option d claims a structural restriction between head and body that does not exist; both tags and elements appear in both sections. Common Pitfalls: A typical confusion arises with empty elements like
or , where there is just one tag but still an element represented in the DOM. Remember that tags are syntax in the HTML source, while elements are nodes that the browser builds from that syntax. Final Answer: The correct distinction is that a tag is the markup keyword enclosed in angle brackets, while an element consists of the start tag, its content, and the end tag treated together.

Technology Questions