## [Haskell], 26 bytes

```haskell
f s=[c|c<-"aba",'b'<-s]==s
```

[Try it online!][TIO-k61uvjuc]

[Haskell]: https://www.haskell.org/
[TIO-k61uvjuc]: https://tio.run/##TYxBCoAwDAS/EoLgxf7AvkQ8JMWqWKUYj77dWK2il2QWZncgmboQVD2IbdzuaoPEhFXJZW2ktVZ0pnEBC3Edlw0KmCmChwaxgqymR8z0UMLEOVyHs3fjK3@dH379jPxfvUex1cP5QL2ocTGe "Haskell – Try It Online"

Checks that the input string is equivalent to the following construction: for each character in `"aba"`, repeat that character once for each `'b'` in the input (checked with the pattern match `'b'<-s`).

An equally-long alternative uses `<*`.

```haskell
f s=("aba"<*[1|'b'<-s])==s
```

[Try it online!][TIO-k61v36zg]

[Haskell]: https://www.haskell.org/
[TIO-k61v36zg]: https://tio.run/##TYxLCoRADESvEoLgB124t08iLhKZVrGVZuLSsxu1ewbdJK/gVY0k88c5VQtiMiQmbIq23lNOm0q63BjRhaYVDPjvtG6QwEIeLLSIJQT/fsRMP7rw4hjuw9EL@JefzguffkR@r4ZR7PToraNBtOq9PwE "Haskell – Try It Online"

# [APL (Dyalog Unicode)], 17 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")^SBCS^
Anonymous tacit prefix function. Requires 0-based indexing (`⎕IO←0`)
```apl
⊂∊'aba'/¨∘⊂⍨∘⍳1⌈≢
```
[Try it online!][TIO-k60fj353]

| Reading order| Notes
| ---- | -----
| `⊂∊` |Is the whole argument a member of
|   `'aba'/¨∘⊂`|the whole of "aba", with its letters replicated by each
|            `∘`  | of
|             `⍳`  | 0, 1, …
|              `1⌈` | the maximum of 1 and
|               `≢`  | the tally of characters?

| Execution order| Notes
| ---- | -----
|               `≢`  | tally the argument
|              `1⌈` | the maximum of 1 and that
|             `⍳`  | 0, 1, … that
|            `∘`  | then
|   `'aba'/¨∘⊂`|For each of those, replicate the characters of "aba"
| `⊂∊` |is the whole argument a member of that list?

[APL (Dyalog Unicode)]: https://www.dyalog.com/
[TIO-k60fj353]: https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/x91NT3q6FJPTEpU1z@04lHHDJBAL5jRu9nwUU/Ho85F/9OASh/19kF0dTUfWm/8qG0ikBcc5AwkQzw8g/@nqatzpYGNAVGJSUmJUBaQCWRDOCAiCaIOzIQpRuhBYiL0Q5hJyKaCDVUHAA "APL (Dyalog Unicode) – Try It Online"

# [Golfscript](http://www.golfscript.com/), 26 bytes

```
..3/,/{.|}/~++"aba"=\,3%!*
```

Not particularly optimal, but the first solution I thought of. Probably could pare down the string-comparison bit into some kind of bitwise comparison. ~++"aba"= is 9 bytes just to check "is the order right", when it could probably be done in 3 somehow. After the loop, we would have (if correct), ["a", "b", "a"], so it should be doable. I'll check some bitwise comparisons later, but this is a good starting benchmark.

Parse;

```
..  #Duplicate the string twice. Stack is now three copies.
  3/  #Divide the string into parts of size 3.
    ,  #Count how many parts there are, and get rid of that copy
     /  #Divide one of the two original strings into three parts
     	#using the prev number
      {.|}/  #For each of these parts, get rid of duplicates
           ~++  #Break them out of the array then concatenate them.
              "aba"=  #Make sure the array followed the pattern of
              		  #1/3 a's, 1/3 b's, then 1/3 a's again.
                      #If so, we replace it with 1. Otherwise 0.
                    \  #Bring that last original-string over.
                     ,3%  #Make sure it's a clean multiple of three.
                        !  #If so, 1. If not, 0.
                         *  #Multiply! 1*1=1, and 0*1 or 0*0=0, so if
                            #both conditions pass, we pass 1.
```

# CJam, 13 bytes

    q_,3/"aba"e*=

[Try it online!](https://tio.run/##S85KzP1fHZ@gpKBrp6Dk8L8wXsdYXykxKVEpVcv2v19tsXqhbl2hn77qfy6gIFdiYlJSIogC0kAGkMWVBJTggkhBpWE0VB2QToLrA2sDAA "CJam – Try It Online")

## Explanation

    q               read the input                     "aabbaa"
      ,             length                             6
       3/           divide by 3                        2
         "aba"e*    repeat elements in string "aba"    "aabbaa"
     _          =   equal to original?                 1

# [W](https://github.com/A-ee/w) [`d`](https://codegolf.meta.stackexchange.com/questions/14337/command-line-flags-on-front-ends/14339#14339), 11 [bytes](https://github.com/A-ee/w/wiki/Code-Page)
```
←▬┴F║`πδE;L
```
Uncompressed:
```
ck3/*"aba"NJ=
```
# Explanation
```
          N   % Map
     "aba"    % the string aba
ck            % The length of the input
  3/          % Divide by 3
    *         % Repeat input by that
           J  % Join the output
            = % Is it equal to original?
```

# [Stax](https://github.com/tomtheisen/stax), 9 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)

	â╢<╜◘@*\@

[Run and debug it](https://staxlang.xyz/#p=83b63cbd08402a5c40&i=%22%22%0A%22aba%22%0A%22aabbaa%22%0A%22aaabbbaaa%22%0A%22a%22%0A%22b%22%0A%22ab%22%0A%22ba%22%0A%22aab%22%0A%22aabbaab%22%0A%22aabbaaa%22%0A%22aaabbaa%22%0A%22baabbaa%22%0A%22aabbbaa%22&a=1&m=2)

Unpacked, ungolfed, and commented, it looks like this.

```
3M	split into 3 approximately equal groups
M	array transpose, inserting 0 to rectangularize
"aba"]-	remove all "aba" elements from array
!	logical not; yields true iff array was empty	
```

[Run this one](https://staxlang.xyz/#c=3M%09split+into+3+approximately+equal+groups%0AM%09array+transpose,+inserting+0+to+rectangularize%0A%22aba%22]-%09remove+all+%22aba%22+elements+from+array%0A%21%09logical+not%3B+yields+true+iff+array+was+empty%09&i=%22%22%0A%22aba%22%0A%22aabbaa%22%0A%22aaabbbaaa%22%0A%22a%22%0A%22b%22%0A%22ab%22%0A%22ba%22%0A%22aab%22%0A%22aabbaab%22%0A%22aabbaaa%22%0A%22aaabbaa%22%0A%22baabbaa%22%0A%22aabbbaa%22&a=1&m=2)

# Clojure (115 bytes)
```clojure
(defn a[s](let[g(re-find #"^(a+)(b+)(a+)$"s)](or(= s"")(and(not(nil? g))(=(count(g 1))(count(g 2))(count(g 3)))))))
```

Ungolfed version:

```clojure
(defn aba?[s]
  (let [ groups  (re-find #"^(a+)(b+)(a+)$" s) ]
    (or (= s "")
        (and (not (nil? groups))
             (= (count (groups 1)) (count (groups 2)) (count (groups 3)))))))
```

## [NST](https://github.com/A-ee/NST), 7 bytes
I want to post in this anyway.

You need to enclose the input in brackets, e.g. `["aba"]`.
```
aba"N*∍
```
## Explanation
```
aba"N*§
aba"     Define the string "aba".
    
    N*   Multiply this string by the natural number set.
         This set is [0, 1, 2, 3, ...]
          
         Since in NST a string is technically a set,
         this yields the output
         ["", "aba", "aabbaa", "aaabbbaaa", ...]
         instead.

      §  Does the (implicit) input belong to this set?
```

# [MathGolf], 13 bytes

    ùabam{l£3/*}=

[Try it online!][TIO-k8wzjgsf]

[MathGolf]: https://github.com/maxbergmark/mathgolf
[TIO-k8wzjgsf]: https://tio.run/##y00syUjPz0n7///wzsSkxNzqnEOLjfW1am3//1dKTExKSkxUAgA "MathGolf – Try It Online"

# [05AB1E], 14 bytes

    …abaεIg3/иJ}JQ

[Try it online!][TIO-k8wz8hqr]

[05AB1E]: https://github.com/Adriandmen/05AB1E
[TIO-k8wz8hqr]: https://tio.run/##yy9OTMpM/f//UcOyxKTEc1s90431L@zwqvUK/P8/MTEpKTERAA "05AB1E – Try It Online"