Computer-aided software engineering

From Wikipedia, the free encyclopedia

Example of a CASE tool

Computer-aided software engineering (CASE) is a domain of software tools used to design and implement applications. CASE tools are similar to and are partly inspired by computer-aided design (CAD) tools used for designing hardware products. CASE tools are intended to help develop high-quality, defect-free, and maintainable software. CASE software was often associated with methods for the development of information systems together with automated tools that could be used in the software development process.

History

The Information System Design and Optimization System (ISDOS) project, started in 1968 at the University of Michigan, initiated a great deal of interest in the whole concept of using computer systems to help analysts in the very difficult process of analysing requirements and developing systems. Several papers by Daniel Teichroew fired a whole generation of enthusiasts with the potential of automated systems development. His Problem Statement Language / Problem Statement Analyzer (PSL/PSA) tool was a CASE tool although it predated the term.

Another major thread emerged as a logical extension to the data dictionary of a database. By extending the range of metadata held, the attributes of an application could be held within a dictionary and used at runtime. This "active dictionary" became the precursor to the more modern model-driven engineering capability. However, the active dictionary did not provide a graphical representation of any of the metadata. It was the linking of the concept of a dictionary holding analysts' metadata, as derived from the use of an integrated set of techniques, together with the graphical representation of such data that gave rise to the earlier versions of CASE.

The next entrant into the market was Excelerator from Index Technology in Cambridge, Mass. While DesignAid ran on Convergent Technologies and later Burroughs Ngen networked microcomputers, Index launched Excelerator on the IBM PC/AT platform. While, at the time of launch, and for several years, the IBM platform did not support networking or a centralized database as did the Convergent Technologies or Burroughs machines, the allure of IBM was strong, and Excelerator came to prominence. Hot on the heels of Excelerator were a rash of offerings from companies such as Knowledgeware (James Martin, Fran Tarkenton and Don Addington), Texas Instrument's CA Gen and Andersen Consulting's FOUNDATION toolset (DESIGN/1, INSTALL/1, FCP).

CASE tools were at their peak in the early 1990s. According to the PC Magazine of January 1990, over 100 companies were offering nearly 200 different CASE tools. At the time IBM had proposed AD/Cycle, which was an alliance of software vendors centered on IBM's Software repository using IBM DB2 in mainframe and OS/2:

The application development tools can be from several sources: from IBM, from vendors, and from the customers themselves. IBM has entered into relationships with Bachman Information Systems, Index Technology Corporation, and Knowledgeware wherein selected products from these vendors will be marketed through an IBM complementary marketing program to provide offerings that will help to achieve complete life-cycle coverage.

With the decline of the mainframe, AD/Cycle and the Big CASE tools died off, opening the market for the mainstream CASE tools of today. Many of the leaders of the CASE market of the early 1990s ended up being purchased by Computer Associates, including IEW, IEF, ADW, Cayenne, and Learmonth & Burchett Management Systems (LBMS). The other trend that led to the evolution of CASE tools was the rise of object-oriented methods and tools. Most of the various tool vendors added some support for object-oriented methods and tools. In addition new products arose that were designed from the bottom up to support the object-oriented approach. Andersen developed its project Eagle as an alternative to Foundation. Several of the thought leaders in object-oriented development each developed their own methodology and CASE tool set: Jacobson, Rumbaugh, Booch, etc. Eventually, these diverse tool sets and methods were consolidated via standards led by the Object Management Group (OMG). The OMG's Unified Modelling Language (UML) is currently widely accepted as the industry standard for object-oriented modeling.

CASE software

Tools

CASE tools support specific tasks in the software development life-cycle. They can be divided into the following categories:

1. Business and analysis modeling: Graphical modeling tools. E.g., E/R modeling, object modeling, etc.
2. Development: Design and construction phases of the life-cycle. Debugging environments. E.g., IISE LKO.
3. Verification and validation: Analyze code and specifications for correctness, performance, etc.
4. Configuration management: Control the check-in and check-out of repository objects and files. E.g., SCCS, IISE.
5. Metrics and measurement: Analyze code for complexity, modularity (e.g., no "go to's"), performance, etc.
6. Project management: Manage project plans, task assignments, scheduling.

Another common way to distinguish CASE tools is the distinction between Upper CASE and Lower CASE. Upper CASE Tools support business and analysis modeling. They support traditional diagrammatic languages such as ER diagrams, Data flow diagram, Structure charts, Decision Trees, Decision tables, etc. Lower CASE Tools support development activities, such as physical design, debugging, construction, testing, component integration, maintenance, and reverse engineering. All other activities span the entire life-cycle and apply equally to upper and lower CASE.

Workbenches

Workbenches integrate two or more CASE tools and support specific software-process activities. Hence they achieve:

• A homogeneous and consistent interface (presentation integration)
• Seamless integration of tools and toolchains (control and data integration)

An example workbench is Microsoft's Visual Basic programming environment. It incorporates several development tools: a GUI builder, a smart code editor, debugger, etc. Most commercial CASE products tended to be such workbenches that seamlessly integrated two or more tools. Workbenches also can be classified in the same manner as tools; as focusing on Analysis, Development, Verification, etc. as well as being focused on the upper case, lower case, or processes such as configuration management that span the complete life-cycle.

Environments

An environment is a collection of CASE tools or workbenches that attempts to support the complete software process. This contrasts with tools that focus on one specific task or a specific part of the life-cycle. CASE environments are classified by Fuggetta as follows:

1. Toolkits: Loosely coupled collections of tools. These typically build on operating system workbenches such as the Unix Programmer's Workbench or the VMS VAX set. They typically perform integration via piping or some other basic mechanism to share data and pass control. The strength of easy integration is also one of the drawbacks. Simple passing of parameters via technologies such as shell scripting can't provide the kind of sophisticated integration that a common repository database can.
2. Fourth generation: These environments are also known as 4GL standing for fourth generation language environments due to the fact that the early environments were designed around specific languages such as Visual Basic. They were the first environments to provide deep integration of multiple tools. Typically these environments were focused on specific types of applications. For example, user-interface driven applications that did standard atomic transactions to a relational database. Examples are Informix 4GL, and Focus.
3. Language-centered: Environments based on a single often object-oriented language such as the Symbolics Lisp Genera environment or VisualWorks Smalltalk from Parcplace. In these environments all the operating system resources were objects in the object-oriented language. This provides powerful debugging and graphical opportunities but the code developed is mostly limited to the specific language. For this reason, these environments were mostly a niche within CASE. Their use was mostly for prototyping and R&D projects. A common core idea for these environments was the model–view–controller user interface that facilitated keeping multiple presentations of the same design consistent with the underlying model. The MVC architecture was adopted by the other types of CASE environments as well as many of the applications that were built with them.
4. Integrated: These environments are an example of what most IT people tend to think of first when they think of CASE. Environments such as IBM's AD/Cycle, Andersen Consulting's FOUNDATION, the ICL CADES system, and DEC Cohesion. These environments attempt to cover the complete life-cycle from analysis to maintenance and provide an integrated database repository for storing all artifacts of the software process. The integrated software repository was the defining feature for these kinds of tools. They provided multiple different design models as well as support for code in heterogenous languages. One of the main goals for these types of environments was "round trip engineering": being able to make changes at the design level and have those automatically be reflected in the code and vice versa. These environments were also typically associated with a particular methodology for software development. For example, the FOUNDATION CASE suite from Andersen was closely tied to the Andersen Method/1 methodology.
5. Process-centered: This is the most ambitious type of integration. These environments attempt to not just formally specify the analysis and design objects of the software process but the actual process itself and to use that formal process to control and guide software projects. Examples are East, Enterprise II, Process Wise, Process Weaver, and Arcadia. These environments were by definition tied to some methodology since the software process itself is part of the environment and can control many aspects of tool invocation.

In practice, the distinction between workbenches and environments was flexible. Visual Basic for example was a programming workbench but was also considered a 4GL environment by many. The features that distinguished workbenches from environments were deep integration via a shared repository or common language and some kind of methodology (integrated and process-centered environments) or domain (4GL) specificity.

Major CASE risk factors

Some of the most significant risk factors for organizations adopting CASE technology include:

• Inadequate standardization: Organizations usually have to tailor and adopt methodologies and tools to their specific requirements. Doing so may require significant effort to integrate both divergent technologies as well as divergent methods. For example, before the adoption of the UML standard the diagram conventions and methods for designing object-oriented models were vastly different among followers of Jacobsen, Booch, and Rumbaugh.
• Unrealistic expectations: The proponents of CASE technology—especially vendors marketing expensive tool sets—often hype expectations that the new approach will be a silver bullet that solves all problems. In reality no such technology can do that and if organizations approach CASE with unrealistic expectations they will inevitably be disappointed.
• Inadequate training: As with any new technology, CASE requires time to train people in how to use the tools and to get up to speed with them. CASE projects can fail if practitioners are not given adequate time for training or if the first project attempted with the new technology is itself highly mission critical and fraught with risk.
• Inadequate process control: CASE provides significant new capabilities to utilize new types of tools in innovative ways. Without the proper process guidance and controls these new capabilities can cause significant new problems as well.

Structured programming

From Wikipedia, the free encyclopedia

Structured programming is a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by making extensive use of the structured control flow constructs of selection (if/then/else) and repetition (while and for), block structures, and subroutines.

It emerged in the late 1950s with the appearance of the ALGOL 58 and ALGOL 60 programming languages, with the latter including support for block structures. Contributing factors to its popularity and widespread acceptance, at first in academia and later among practitioners, include the discovery of what is now known as the structured program theorem in 1966, and the publication of the influential "Go To Statement Considered Harmful" open letter in 1968 by Dutch computer scientist Edsger W. Dijkstra, who coined the term "structured programming".

Structured programming is most frequently used with deviations that allow for clearer programs in some particular cases, such as when exception handling has to be performed.

Elements

Control structures

Following the structured program theorem, all programs are seen as composed of three control structures:

• "Sequence"; ordered statements or subroutines executed in sequence.
• "Selection"; one or a number of statements is executed depending on the state of the program. This is usually expressed with keywords such as if..then..else..endif. The conditional statement should have at least one true condition and each condition should have one exit point at max.
• "Iteration"; a statement or block is executed until the program reaches a certain state, or operations have been applied to every element of a collection. This is usually expressed with keywords such as while, repeat, for or do..until. Often it is recommended that each loop should only have one entry point (and in the original structural programming, also only one exit point, and a few languages enforce this).

Graphical representation of the three basic patterns — sequence, selection, and repetition — using NS diagrams (blue) and flow charts (green).

Subroutines

Subroutines; callable units such as procedures, functions, methods, or subprograms are used to allow a sequence to be referred to by a single statement.

Blocks

Blocks are used to enable groups of statements to be treated as if they were one statement. Block-structured languages have a syntax for enclosing structures in some formal way, such as an if-statement bracketed by if..fi as in ALGOL 68, or a code section bracketed by BEGIN..END, as in PL/I and Pascal, whitespace indentation as in Python, or the curly braces {...} of C and many later languages.

Structured programming languages

It is possible to do structured programming in any programming language, though it is preferable to use something like a procedural programming language. Some of the languages initially used for structured programming include: ALGOL, Pascal, PL/I, Ada and RPL but most new procedural programming languages since that time have included features to encourage structured programming, and sometimes deliberately left out features – notably GOTO – in an effort to make unstructured programming more difficult.

Structured programming (sometimes known as modular programming) enforces a logical structure on the program being written to make it more efficient and easier to understand and modify.

History

Theoretical foundation

The structured program theorem provides the theoretical basis of structured programming. It states that three ways of combining programs—sequencing, selection, and iteration—are sufficient to express any computable function. This observation did not originate with the structured programming movement; these structures are sufficient to describe the instruction cycle of a central processing unit, as well as the operation of a Turing machine. Therefore, a processor is always executing a "structured program" in this sense, even if the instructions it reads from memory are not part of a structured program. However, authors usually credit the result to a 1966 paper by Böhm and Jacopini, possibly because Dijkstra cited this paper himself. The structured program theorem does not address how to write and analyze a usefully structured program. These issues were addressed during the late 1960s and early 1970s, with major contributions by Dijkstra, Robert W. Floyd, Tony Hoare, Ole-Johan Dahl, and David Gries.

Debate

P. J. Plauger, an early adopter of structured programming, described his reaction to the structured program theorem:

Us converts waved this interesting bit of news under the noses of the unreconstructed assembly-language programmers who kept trotting forth twisty bits of logic and saying, 'I betcha can't structure this.' Neither the proof by Böhm and Jacopini nor our repeated successes at writing structured code brought them around one day sooner than they were ready to convince themselves.

Donald Knuth accepted the principle that programs must be written with provability in mind, but he disagreed with abolishing the GOTO statement, and as of 2018 has continued to use it in his programs. In his 1974 paper, "Structured Programming with Goto Statements", he gave examples where he believed that a direct jump leads to clearer and more efficient code without sacrificing provability. Knuth proposed a looser structural constraint: It should be possible to draw a program's flow chart with all forward branches on the left, all backward branches on the right, and no branches crossing each other. Many of those knowledgeable in compilers and graph theory have advocated allowing only reducible flow graphs.

Structured programming theorists gained a major ally in the 1970s after IBM researcher Harlan Mills applied his interpretation of structured programming theory to the development of an indexing system for The New York Times research file. The project was a great engineering success, and managers at other companies cited it in support of adopting structured programming, although Dijkstra criticized the ways that Mills's interpretation differed from the published work.

As late as 1987 it was still possible to raise the question of structured programming in a computer science journal. Frank Rubin did so in that year with an open letter titled "'GOTO Considered Harmful' Considered Harmful". Numerous objections followed, including a response from Dijkstra that sharply criticized both Rubin and the concessions other writers made when responding to him.

Outcome

By the end of the 20th century, nearly all computer scientists were convinced that it is useful to learn and apply the concepts of structured programming. High-level programming languages that originally lacked programming structures, such as FORTRAN, COBOL, and BASIC, now have them.

Common deviations

While goto has now largely been replaced by the structured constructs of selection (if/then/else) and repetition (while and for), few languages are purely structured. The most common deviation, found in many languages, is the use of a return statement for early exit from a subroutine. This results in multiple exit points, instead of the single exit point required by structured programming. There are other constructions to handle cases that are awkward in purely structured programming.

Early exit

Further information: Return early

The most common deviation from structured programming is early exit from a function or loop. At the level of functions, this is a return statement. At the level of loops, this is a break statement (terminate the loop) or continue statement (terminate the current iteration, proceed with next iteration). In structured programming, these can be replicated by adding additional branches or tests, but for returns from nested code this can add significant complexity. C is an early and prominent example of these constructs. Some newer languages also have "labeled breaks", which allow breaking out of more than just the innermost loop. Exceptions also allow early exit, but have further consequences, and thus are treated below.

Multiple exits can arise for a variety of reasons, most often either that the subroutine has no more work to do (if returning a value, it has completed the calculation), or has encountered "exceptional" circumstances that prevent it from continuing, hence needing exception handling.

The most common problem in early exit is that cleanup or final statements are not executed – for example, allocated memory is not deallocated, or open files are not closed, causing memory leaks or resource leaks. These must be done at each return site, which is brittle and can easily result in bugs. For instance, in later development, a return statement could be overlooked by a developer, and an action that should be performed at the end of a subroutine (e.g., a trace statement) might not be performed in all cases. Languages without a return statement, such as standard Pascal and Seed7, do not have this problem.

Most modern languages provide language-level support to prevent such leaks; see detailed discussion at resource management. Most commonly this is done via unwind protection, which ensures that certain code is guaranteed to be run when execution exits a block; this is a structured alternative to having a cleanup block and a goto. This is most often known as try...finally, and considered a part of exception handling. In case of multiple return statements introducing try...finally, without exceptions might look strange. Various techniques exist to encapsulate resource management. An alternative approach, found primarily in C++, is Resource Acquisition Is Initialization, which uses normal stack unwinding (variable deallocation) at function exit to call destructors on local variables to deallocate resources.

Kent Beck, Martin Fowler and co-authors have argued in their refactoring books that nested conditionals may be harder to understand than a certain type of flatter structure using multiple exits predicated by guard clauses. Their 2009 book flatly states that "one exit point is really not a useful rule. Clarity is the key principle: If the method is clearer with one exit point, use one exit point; otherwise don’t". They offer a cookbook solution for transforming a function consisting only of nested conditionals into a sequence of guarded return (or throw) statements, followed by a single unguarded block, which is intended to contain the code for the common case, while the guarded statements are supposed to deal with the less common ones (or with errors). Herb Sutter and Andrei Alexandrescu also argue in their 2004 C++ tips book that the single-exit point is an obsolete requirement.

In his 2004 textbook, David Watt writes that "single-entry multi-exit control flows are often desirable". Using Tennent's framework notion of sequencer, Watt uniformly describes the control flow constructs found in contemporary programming languages and attempts to explain why certain types of sequencers are preferable to others in the context of multi-exit control flows. Watt writes that unrestricted gotos (jump sequencers) are bad because the destination of the jump is not self-explanatory to the reader of a program until the reader finds and examines the actual label or address that is the target of the jump. In contrast, Watt argues that the conceptual intent of a return sequencer is clear from its own context, without having to examine its destination. Watt writes that a class of sequencers known as escape sequencers, defined as a "sequencer that terminates execution of a textually enclosing command or procedure", encompasses both breaks from loops (including multi-level breaks) and return statements. Watt also notes that while jump sequencers (gotos) have been somewhat restricted in languages like C, where the target must be an inside the local block or an encompassing outer block, that restriction alone is not sufficient to make the intent of gotos in C self-describing and so they can still produce "spaghetti code". Watt also examines how exception sequencers differ from escape and jump sequencers; this is explained in the next section of this article.

In contrast to the above, Bertrand Meyer wrote in his 2009 textbook that instructions like break and continue "are just the old goto in sheep's clothing" and strongly advised against their use.

Exception handling

Further information: Exception handling (programming)

Based on the coding error from the Ariane 501 disaster, software developer Jim Bonang argues that any exceptions thrown from a function violate the single-exit paradigm, and proposes that all inter-procedural exceptions should be forbidden. Bonang proposes that all single-exit conforming C++ should be written along the lines of:

bool MyCheck1() throw() {
  bool success = false;
  try {
    // Do something that may throw exceptions.
    if (!MyCheck2()) {
      throw SomeInternalException();
    }
    // Other code similar to the above.
    success = true;
  } catch (...) {
    // All exceptions caught and logged.
  }
  return success;
}

Peter Ritchie also notes that, in principle, even a single throw right before the return in a function constitutes a violation of the single-exit principle, but argues that Dijkstra's rules were written in a time before exception handling became a paradigm in programming languages, so he proposes to allow any number of throw points in addition to a single return point. He notes that solutions that wrap exceptions for the sake of creating a single-exit have higher nesting depth and thus are more difficult to comprehend, and even accuses those who propose to apply such solutions to programming languages that support exceptions of engaging in cargo cult thinking.

David Watt also analyzes exception handling in the framework of sequencers (introduced in this article in the previous section on early exits.) Watt notes that an abnormal situation (generally exemplified with arithmetic overflows or input/output failures like file not found) is a kind of error that "is detected in some low-level program unit, but [for which] a handler is more naturally located in a high-level program unit". For example, a program might contain several calls to read files, but the action to perform when a file is not found depends on the meaning (purpose) of the file in question to the program and thus a handling routine for this abnormal situation cannot be located in low-level system code. Watts further notes that introducing status flags testing in the caller, as single-exit structured programming or even (multi-exit) return sequencers would entail, results in a situation where "the application code tends to get cluttered by tests of status flags" and that "the programmer might forgetfully or lazily omit to test a status flag. In fact, abnormal situations represented by status flags are by default ignored!" He notes that in contrast to status flags testing, exceptions have the opposite default behavior, causing the program to terminate unless the programmer explicitly deals with the exception in some way, possibly by adding code to willfully ignore it. Based on these arguments, Watt concludes that jump sequencers or escape sequencers (discussed in the previous section) are not as suitable as a dedicated exception sequencer with the semantics discussed above.

The textbook by Louden and Lambert emphasizes that exception handling differs from structured programming constructs like while loops because the transfer of control "is set up at a different point in the program than that where the actual transfer takes place. At the point where the transfer actually occurs, there may be no syntactic indication that control will in fact be transferred." Computer science professor Arvind Kumar Bansal also notes that in languages which implement exception handling, even control structures like for, which have the single-exit property in absence of exceptions, no longer have it in presence of exceptions, because an exception can prematurely cause an early exit in any part of the control structure; for instance if init() throws an exception in for (init(); check(); increm()), then the usual exit point after check() is not reached. Citing multiple prior studies by others (1999–2004) and their own results, Westley Weimer and George Necula wrote that a significant problem with exceptions is that they "create hidden control-flow paths that are difficult for programmers to reason about".

The necessity to limit code to single-exit points appears in some contemporary programming environments focused on parallel computing, such as OpenMP. The various parallel constructs from OpenMP, like parallel do, do not allow early exits from inside to the outside of the parallel construct; this restriction includes all manner of exits, from break to C++ exceptions, but all of these are permitted inside the parallel construct if the jump target is also inside it.

Multiple entry

Further information: Coroutine

More rarely, subprograms allow multiple entry. This is most commonly only re-entry into a coroutine (or generator/semicoroutine), where a subprogram yields control (and possibly a value), but can then be resumed where it left off. There are a number of common uses of such programming, notably for streams (particularly input/output), state machines, and concurrency. From a code execution point of view, yielding from a coroutine is closer to structured programming than returning from a subroutine, as the subprogram has not actually terminated, and will continue when called again – it is not an early exit. However, coroutines mean that multiple subprograms have execution state – rather than a single call stack of subroutines – and thus introduce a different form of complexity.

It is very rare for subprograms to allow entry to an arbitrary position in the subprogram, as in this case the program state (such as variable values) is uninitialized or ambiguous, and this is very similar to a goto.

State machines

Some programs, particularly parsers and communications protocols, have a number of states that follow each other in a way that is not easily reduced to the basic structures, and some programmers implement the state-changes with a jump to the new state. This type of state-switching is often used in the Linux kernel.

However, it is possible to structure these systems by making each state-change a separate subprogram and using a variable to indicate the active state (see trampoline). Alternatively, these can be implemented via coroutines, which dispense with the trampoline.

Politics of Europe

From Wikipedia, the free encyclopedia

https://en.wikipedia.org/wiki/Politics_of_Europe

A clickable Euler diagram showing the relationships between various multinational European organisations and agreements

The politics of Europe deals with the continually evolving politics within the continent of Europe. It is a topic far more detailed than other continents due to a number of factors including the long history of nation states in the region as well as the modern day trend towards increased political unity amongst the European states.

The current politics of Europe can be traced back to historical events within the continent. Likewise geography, economy, and culture have contributed to the current political make-up of Europe.

Modern European politics is dominated by the European Union, since the fall of the Iron Curtain and the collapse of the Eastern Bloc of Communist states. After the end of the Cold War, the EU expanded eastward to include the former Communist countries. As of 31 January 2020, the EU has 27 member states.

However, there are a number of other international organizations made up predominantly of European nations, or explicitly claiming a European origin, including the 46-nation Council of Europe - the first post-war European organization, regarded as a fore-runner to the European Union - and the 57-nation Organization for Security and Co-operation in Europe (OSCE).

Modern political climate

Map of European nations coloured by percentage of vote governing party got in last election as of 2022

Despite vastly improved relations between Russia and the Western European states since the end of the cold war, recently tensions have risen over the spread of "Western" organizations, particularly the EU and NATO, eastwards into former USSR states.

Many European states have either joined or stated their ambition to join the European Union.

There are few conflicts within Europe, although there remain problems in the Western Balkans, the Caucasus, Northern Ireland in the United Kingdom and the Basque Country in Spain.

According to 2007 data published in 2008 by Freedom House, the countries of Europe that cannot be classified liberal electoral democracies are Azerbaijan, Belarus, Bosnia, Kazakhstan and Russia.

International unions, organizations and alliances

  EU member state

  EEA member or EU candidate state

  GUAM member state

  EurAsEC member state

European states are members of a large number of international organizations, mainly economical, although several are political, or both. The main political unions are detailed below.

European Union

Also see: Politics of the European Union, Enlargement of the European Union, Future enlargement of the European Union, Foreign relations of the European Union, Eastern Partnership

The European Union, or EU, is a political union of 27 states. It has many activities, the most important being a common single market, consisting of a customs union, a single currency (adopted by 20 of 27 member states), a Common Agricultural Policy and a Common Fisheries Policy. The European Union also has various initiatives to co-ordinate activities of the member states.

The EU, considered as a unit, has the second largest economy in the world with a nominal GDP of 14.9 trillion USD in 2020. There is also a trend of moving towards increased co-operation in terms of common defense and foreign policy.

The union has evolved over time from a primarily economic union to an increasingly political one. This trend is highlighted by the increasing number of policy areas that fall within EU competence; political power has tended to shift upwards from the member states to the EU. The further development of the political competencies of the EU is the subject of heavy debate within and between some member states.

Council of Europe

Main article: Council of Europe

The Council of Europe brings together 46 European nations - the entire continent with the exception of Russia, which was expelled in 2022 following its invasion of Ukraine, and Belarus. Founded in 1949, it is the oldest of the European organizations, embodying post-war hopes for peaceful co-operation, and is focused on the three statutory aims of promoting human rights, democracy and the rule of law. It does not deal with economic matters or defense. Its main achievement is the European Convention on Human Rights, which binds its 46 contracting parties to uphold the basic human rights of their citizens, and the Strasbourg Court which enforces it. The Council of Europe is regarded as a classic intergovernmental organization, with a parliamentary arm, and has none of the supranational powers of the EU – thus it could be compared to a regional version of the United Nations.

European Political Community

Main article: European Political Community

The European Political Community (EPC) was formed in October 2022 after the Russian invasion of Ukraine. The group first met in October 2022 in Prague, with participants from 44 European countries, as well as representatives of the European Union. Russia and Belarus were not invited to the inaugural meeting. It is envisioned that the group will meet twice in plenary session twice each year.

Community of Democratic Choice

Main article: Community of Democratic Choice

The Community of Democratic Choice (CDC) was formed in December 2005 at the primary instigation of Ukraine and Georgia, and composed of six Post-Soviet states (Ukraine, Georgia, Moldova, and the three Baltic Assembly members of Estonia, Latvia and Lithuania) and three other countries of Eastern and Central Europe (Slovenia, Romania and North Macedonia). The Black Sea Forum (BSF) is a closely related organization. Observer countries include Armenia, Bulgaria, and Poland.

Just like GUAM before it, this forum is largely seen as intending to counteract Russian influence in the area. This is the only international forum centered in the post-Soviet space in which the Baltic states also participate. The other three post-Soviet states in it are all members of GUAM.

Eurasian Economic Union

Main articles: Eurasian Union and Enlargement of the Eurasian Economic Union

The Eurasian Economic Union is an economic union of post-Soviet states. The treaty aiming for the establishment of the EEU was signed on 29 May 2014 by the leaders of Belarus, Kazakhstan and Russia, and came into force on 1 January 2015. Treaties aiming for Armenia's and Kyrgyzstan's accession to the Eurasian Economic Union were signed on 9 October 2014 and 23 December respectively. Armenia's accession treaty came into force on 2 January 2015. Although Kyrgyzstan's accession treaty did not come into force until May 2015, provided it has been ratified, it will participate in the EEU from the day of its establishment as an acceding state. Moldova and Tajikistan are prospective members.

Euronest Parliamentary Assembly

The Euronest Parliamentary Assembly is the inter-parliamentary forum in which members of the European Parliament and the national parliaments of Ukraine, Moldova, Belarus, Armenia, Azerbaijan and Georgia participate and forge closer political and economic ties with the European Union.^[23]

Commonwealth of Independent States

The Commonwealth of Independent States (CIS) is a confederation consisting of 12 of the 15 states of the former Soviet Union, (the exceptions being the three Baltic states). Although the CIS has few supranational powers, it is more than a purely symbolic organization and possesses coordinating powers in the realm of trade, finance, lawmaking and security. The most significant issue for the CIS is the establishment of a full-fledged free trade zone and economic union between the member states, launched in 2005. It has also promoted co-operation on democratization and cross-border crime prevention. Additionally, six members of the CIS signed on to a collective security treaty known as the Collective Security Treaty Organization.

Community for Democracy and Rights of Nations

Main article: Community for Democracy and Rights of Nations

The post-Soviet disputed states of Abkhazia, South Ossetia, and Transnistria are all members of the Community for Democracy and Rights of Nations which aims to forge closer integration among the members.

North Atlantic Treaty Organization

Main articles: NATO, Foreign relations of NATO, Individual Partnership Action Plan, and Partnership for Peace

The North Atlantic Treaty Organization (NATO) is a military alliance of mainly European states, together with the United States of America and Canada. The organization was founded as a collective security measure following Second World War.

This provision was intended so that if the Soviet Union launched an attack against the European allies of the United States, it would be treated as if it were an attack on the United States itself, which had the biggest military and could thus provide the most significant retaliation. However, the feared Soviet invasion of Europe never came. Instead, the provision was invoked for the first time in the treaty's history on 12 September 2001, in response to the attacks of 11 September on the United States the day before.

GUAM Organization for Democracy and Economic Development

GUAM Organization for Democracy and Economic Development is a regional organization of four CIS states: Georgia, Ukraine, Azerbaijan, and Moldova. The group was created as a way of countering the influence of Russia in the area, and it has received backing and encouragement from the United States . Though at one point it was generally considered to have stagnated, recent developments have caused speculation on the possible revival of the organization.

Secessionist and devolutionary pressures

Main article: List of active separatist movements in Europe

These movements, seeking either autonomy or independence, vary greatly in their popular support and political profile, from fringe movements to mainstream campaigns.

Belgium

Two of Belgium's political parties, the Vlaams Belang and New-Flemish Alliance, want Flanders, the northern part of the country, to become independent. Other Flemish parties plead for more regional autonomy. There is also a minor movement aiming at unification of Flanders with the Netherlands (see Greater Netherlands).

The autonomous Belgian region of Wallonia has an almost extinct movement seeking unification with France.

Bosnia and Herzegovina

Some inhabitants of Republika Srpska, one of the two constituent entities in Bosnia and Herzegovina (the other being the Federation of Bosnia and Herzegovina), the vast majority of them being ethnic Serbs, would opt for independence from Bosnia and Herzegovina and unification with Serbia. Republika Srpska comprises 49% of the territory of Bosnia and functions independently from the rest of the country in many spheres. Even though independence is not on the official government agenda, Serbian politicians from the region see a link between a possible future status of Kosovo and the status of Republika Srpska.

Croats, who remain a constituent nation of Bosnia and Herzegovina remain united with ethnic Bosniaks in a joint entity. Some Bosnian Croat politicians have proposed a separate constituent entity for Croats along the lines of the Republika Srpska.

Denmark

The Danish territories of Greenland and Faroe Islands have very strong independence movements. Greenland's autonomy marks it as a constituent country under the Danish kingdom.

Finland

The Åland Islands has an autonomy. In 2003, the Ålandian separatist party Ålands Framtid was formed. There has not been much support for full independence since the Independence of Finland, but in the last years the support has slightly grown.

France

The Mediterranean island of Corsica has a significant and growing group calling for independence from France. There are also movements in the Brittany region of northern France who wish to regain independence lost in 1532, and in Savoy in the south east, which was annexed to France following a disputed referendum in 1860.

Parts of Navarre, Basque Country and Catalonia cross into France.

Georgia

South Ossetia declared independence on 28 November 1991, and Abkhazia on 23 July 1992. Following the brief 2008 South Ossetia war, both entities were partially recognised as independent by several UN member states. Georgia considers both "occupied territories" within its own borders. Both states participate in the Community for Democracy and Rights of Nations.

Italy

Lega Nord, a party which is especially strong in Veneto (Liga Veneta) and Lombardy (Lega Lombarda), has promoted either secession or larger autonomy for Northern Italy under the name Padania, blaming Southern Italy for siphoning away tax funds and blocking progress. Similar groups are active in Southern Italy, but can rely on a far smaller electoral support. Plenty of autonomist and separatist parties are active in Northern regions: Valdostan Union, South Tyrolean People's Party, Die Freiheitlichen, Trentino Tyrolean Autonomist Party, North-East Union, Veneto State, etc.

In the province of South Tyrol the South Tyrolean Freedom party, which campaigned for the reunion of the province with Austria, while in Sardinia the Independence Republic of Sardinia supports outright independence for the region. The Mediterranean region is home to many autonomist parties: Sardinian Action Party, Sardinian Reformers, Sardinian People's Party, Union of Sardinians, Red Moors, etc.

Autonomist presidents lead four out twenty regions of Italy: Veneto (Luca Zaia, Łiga Veneta), Aosta Valley (Augusto Rollandin, Valdostan Union), Lombardy (Roberto Maroni, Lega Lombarda) and Trentino-Alto Adige/Südtirol (Lorenzo Dellai, Union for Trentino).

Moldova

The eastern Moldovan region of Transnistria, which has a large ethnic Russian and Ukrainian population, has declared independence from Moldova on 2 September 1990 and is a member of the Community for Democracy and Rights of Nations. Despite having no control over the region, the Moldovan government refuses to recognise this claim. There is a significant movement in Moldova and Romania aiming at the reunification of the two countries.

Netherlands

The Frisian National Party seeks more autonomy for Friesland without striving for complete independence. The preservation of Frisian culture is an important goal of the party.

Romania

Before the Treaty of Trianon after World War I, Transylvania belonged to Austria-Hungary, and it contains minorities of ethnic Hungarians who desire regional autonomy in the country.

Russia

Several of Russia's regions have independence movements, mostly in the state's north Caucasus border. The most notable of these are Chechnya, Dagestan and Ingushetia, which have well supported guerrilla groups involved in open conflict with the Russian authorities.

Some Tatar people seek independence for the region of Tatarstan

Serbia

The status of Kosovo is the subject of a long-running political and territorial dispute between the Serbian (and previously, the Yugoslav) government and Kosovo's largely ethnic-Albanian population. International negotiations began in 2006 to determine final status (See Kosovo status process). Kosovo declared independence on 17 February 2008.

Spain

Main article: Politics of Spain

Within Spain there are independence movements in some of the autonomous regions, notably the regions that have co-official languages such as Catalonia, the Basque Country, and Galicia. These are mostly peaceful but some, such as ETA and Terra Lliure, have used violent means.

Ukraine

The Ukrainian autonomous region of Crimea has been annexed by the Russian Federation. The eastern, majority Russophone part of the country is divided, and there are calls from some groups for the area to leave Ukraine and join Russia.

United Kingdom

Main article: Politics of the United Kingdom

In Northern Ireland, Sinn Féin and the Social Democratic and Labour Party achieve between them around 40% of the vote at elections, with both parties supporting Northern Ireland leaving the United Kingdom and joining Ireland to create a United Ireland.

In Scotland, the Scottish National Party (SNP), the Scottish Greens, the Scottish Socialist Party (SSP) and the Alba Party all support Scottish independence. The SNP won an outright majority at the 2011 Scottish Parliament election and held the 2014 Scottish independence referendum, in the majority of Scottish voters backed remaining part of the United Kingdom by a 55% - 45% margin. There have, however, been revived calls for independence since the 2016 EU referendum, which saw both Scotland and Northern Ireland vote to Remain.

In Wales, Plaid Cymru and the Propel support Welsh independence. Polls generally show support for Welsh independence at around 20-25%.^[54]

In England, there are movements, such as the English Democrats, calling for a devolved English Parliament. There are also movements, such as the Wessex Regionalists, calling for devolution of power to the English regions. Movements seeking autonomy or independence include Mebyon Kernow in the peninsula of Cornwall.

As of 24 June 2016, the United Kingdom officially voted to leave the European Union. It is currently an ongoing process before the process of withdrawing officially begun on 29 March 2019. However, individual constituent countries within the United Kingdom, more specifically Scotland and Northern Ireland voted to remain in the European Union, prompting calls for another independence referendum in Scotland as well as raising the possibility of Irish reunification.